atlas-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From shweth...@apache.org
Subject [1/5] incubator-atlas git commit: ATLAS-1171 Structured, high-level public APIs (mneethiraj via shwethags)
Date Sun, 02 Oct 2016 13:35:21 GMT
Repository: incubator-atlas
Updated Branches:
  refs/heads/master a52112d86 -> 2a441bec1


http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasClassificationType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasClassificationType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasClassificationType.java
new file mode 100644
index 0000000..fc2de25
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasClassificationType.java
@@ -0,0 +1,125 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import java.util.*;
+
+import org.apache.atlas.exception.AtlasBaseException;
+import org.apache.atlas.model.ModelTestUtil;
+import org.apache.atlas.model.instance.AtlasClassification;
+import org.apache.atlas.model.typedef.AtlasBaseTypeDef;
+import org.apache.atlas.model.typedef.AtlasClassificationDef;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasClassificationType {
+    private final AtlasClassificationType classificationType;
+    private final List<Object>            validValues        = new ArrayList<Object>();
+    private final List<Object>            invalidValues      = new ArrayList<Object>();
+
+    {
+        classificationType = getClassificationType(ModelTestUtil.getClassificationDefWithSuperTypes());
+
+        AtlasClassification invalidValue1 = classificationType.createDefaultValue();
+        AtlasClassification invalidValue2 = classificationType.createDefaultValue();
+        Map<String, Object> invalidValue3 = classificationType.createDefaultValue().getAttributes();
+
+        // invalid value for int
+        invalidValue1.setAttribute(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_INT), "xyz");
+        // invalid value for date
+        invalidValue2.setAttribute(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_DATE), "xyz");
+        // invalid value for bigint
+        invalidValue3.put(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_BIGINTEGER), "xyz");
+
+        validValues.add(null);
+        validValues.add(classificationType.createDefaultValue());
+        validValues.add(classificationType.createDefaultValue().getAttributes()); // Map<String, Object>
+        invalidValues.add(invalidValue1);
+        invalidValues.add(invalidValue2);
+        invalidValues.add(invalidValue3);
+        invalidValues.add(new AtlasClassification());     // no values for mandatory attributes
+        invalidValues.add(new HashMap<Object, Object>()); // no values for mandatory attributes
+        invalidValues.add(1);               // incorrect datatype
+        invalidValues.add(new HashSet());   // incorrect datatype
+        invalidValues.add(new ArrayList()); // incorrect datatype
+        invalidValues.add(new String[] {}); // incorrect datatype
+    }
+
+    @Test
+    public void testClassificationTypeDefaultValue() {
+        AtlasClassification defValue = classificationType.createDefaultValue();
+
+        assertNotNull(defValue);
+        assertEquals(defValue.getTypeName(), classificationType.getTypeName());
+    }
+
+    @Test
+    public void testClassificationTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(classificationType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(classificationType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testClassificationTypeGetNormalizedValue() {
+        assertNull(classificationType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Object normalizedValue = classificationType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(classificationType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testClassificationTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(classificationType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(classificationType.validateValue(value, "testObj", messages));
+            assertTrue(messages.size() > 0, "value=" + value);
+            messages.clear();
+        }
+    }
+
+    private static AtlasClassificationType getClassificationType(AtlasClassificationDef classificationDef) {
+        try {
+            return new AtlasClassificationType(classificationDef, ModelTestUtil.getTypesRegistry());
+        } catch (AtlasBaseException excp) {
+            return null;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasDateType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasDateType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasDateType.java
new file mode 100644
index 0000000..a28840a
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasDateType.java
@@ -0,0 +1,132 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.model.typedef.AtlasBaseTypeDef;
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasDateType;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Date;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasDateType {
+    private final AtlasDateType dateType = new AtlasDateType();
+
+    private final Object[] validValues    = {
+        null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1),
+        Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1",
+    };
+
+    private final Object[] negativeValues = {
+        Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1),
+        Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1",
+    };
+
+    private final Object[] invalidValues  = { "", "12ab", "abcd", "-12ab", };
+
+    private final Date   now    = new Date();
+    private final String strNow = AtlasBaseTypeDef.DATE_FORMATTER.format(now);
+
+    @Test
+    public void testDateTypeDefaultValue() {
+        Date defValue = dateType.createDefaultValue();
+
+        assertEquals(defValue, new Date(0));
+    }
+
+    @Test
+    public void testDateTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(dateType.isValidValue(value), "value=" + value);
+        }
+
+        assertTrue(dateType.isValidValue(now), "value=" + now);
+        assertTrue(dateType.isValidValue(strNow), "value=" + strNow);
+
+        for (Object value : negativeValues) {
+            assertTrue(dateType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(dateType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testDateTypeGetNormalizedValue() {
+        assertNull(dateType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Date normalizedValue = dateType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, new Date(1), "value=" + value);
+        }
+
+        assertNotNull(dateType.getNormalizedValue(now), "value=" + now);
+        assertEquals(dateType.getNormalizedValue(now), now, "value=" + now);
+        assertNotNull(dateType.getNormalizedValue(strNow), "value=" + strNow);
+        assertEquals(dateType.getNormalizedValue(now), now, "value=" + now);
+
+        for (Object value : negativeValues) {
+            Date normalizedValue = dateType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, new Date(-1), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(dateType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testDateTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(dateType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        assertTrue(dateType.validateValue(now, "testObj", messages));
+        assertEquals(messages.size(), 0, "value=" + now);
+        assertTrue(dateType.validateValue(strNow, "testObj", messages));
+        assertEquals(messages.size(), 0, "value=" + strNow);
+
+        for (Object value : negativeValues) {
+            assertTrue(dateType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(dateType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 1, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java
new file mode 100644
index 0000000..1b1e013
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java
@@ -0,0 +1,115 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasDoubleType;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasDoubleType {
+    private final AtlasDoubleType doubleType  = new AtlasDoubleType();
+
+    private final Object[] validValues = {
+        null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1),
+        Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1",
+    };
+
+    private final Object[] negativeValues = {
+        Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1),
+        Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1",
+    };
+
+    private final Object[] invalidValues  = { "", "12ab", "abcd", "-12ab", };
+
+
+    @Test
+    public void testDoubleTypeDefaultValue() {
+        Double defValue = doubleType.createDefaultValue();
+
+        assertEquals(defValue, Double.valueOf(0));
+    }
+
+    @Test
+    public void testDoubleTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(doubleType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(doubleType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(doubleType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testDoubleTypeGetNormalizedValue() {
+        assertNull(doubleType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Double normalizedValue = doubleType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Double.valueOf(1), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            Double normalizedValue = doubleType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Double.valueOf(-1), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(doubleType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testDoubleTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(doubleType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(doubleType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(doubleType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 1, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasEntityType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasEntityType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasEntityType.java
new file mode 100644
index 0000000..8139fd4
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasEntityType.java
@@ -0,0 +1,125 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import java.util.*;
+
+import org.apache.atlas.exception.AtlasBaseException;
+import org.apache.atlas.model.ModelTestUtil;
+import org.apache.atlas.model.instance.AtlasEntity;
+import org.apache.atlas.model.typedef.AtlasBaseTypeDef;
+import org.apache.atlas.model.typedef.AtlasEntityDef;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasEntityType {
+    private final AtlasEntityType entityType;
+    private final List<Object>    validValues   = new ArrayList<Object>();
+    private final List<Object>    invalidValues = new ArrayList<Object>();
+
+    {
+        entityType = getEntityType(ModelTestUtil.getEntityDefWithSuperTypes());
+
+        AtlasEntity         invalidValue1 = entityType.createDefaultValue();
+        AtlasEntity         invalidValue2 = entityType.createDefaultValue();
+        Map<String, Object> invalidValue3 = entityType.createDefaultValue().getAttributes();
+
+        // invalid value for int
+        invalidValue1.setAttribute(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_INT), "xyz");
+        // invalid value for date
+        invalidValue2.setAttribute(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_DATE), "xyz");
+        // invalid value for bigint
+        invalidValue3.put(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_BIGINTEGER), "xyz");
+
+        validValues.add(null);
+        validValues.add(entityType.createDefaultValue());
+        validValues.add(entityType.createDefaultValue().getAttributes()); // Map<String, Object>
+        invalidValues.add(invalidValue1);
+        invalidValues.add(invalidValue2);
+        invalidValues.add(invalidValue3);
+        invalidValues.add(new AtlasEntity());             // no values for mandatory attributes
+        invalidValues.add(new HashMap<Object, Object>()); // no values for mandatory attributes
+        invalidValues.add(1);               // incorrect datatype
+        invalidValues.add(new HashSet());   // incorrect datatype
+        invalidValues.add(new ArrayList()); // incorrect datatype
+        invalidValues.add(new String[] {}); // incorrect datatype
+    }
+
+    @Test
+    public void testEntityTypeDefaultValue() {
+        AtlasEntity defValue = entityType.createDefaultValue();
+
+        assertNotNull(defValue);
+        assertEquals(defValue.getTypeName(), entityType.getTypeName());
+    }
+
+    @Test
+    public void testEntityTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(entityType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(entityType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testEntityTypeGetNormalizedValue() {
+        assertNull(entityType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Object normalizedValue = entityType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(entityType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testEntityTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(entityType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(entityType.validateValue(value, "testObj", messages));
+            assertTrue(messages.size() > 0, "value=" + value);
+            messages.clear();
+        }
+    }
+
+    private static AtlasEntityType getEntityType(AtlasEntityDef entityDef) {
+        try {
+            return new AtlasEntityType(entityDef, ModelTestUtil.getTypesRegistry());
+        } catch (AtlasBaseException excp) {
+            return null;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java
new file mode 100644
index 0000000..dbfcf1d
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java
@@ -0,0 +1,115 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasFloatType;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasFloatType {
+    private final AtlasFloatType floatType  = new AtlasFloatType();
+
+    private final Object[] validValues = {
+        null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1),
+        Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1",
+    };
+
+    private final Object[] negativeValues = {
+        Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1),
+        Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1",
+    };
+
+    private final Object[] invalidValues  = { "", "12ab", "abcd", "-12ab", };
+
+
+    @Test
+    public void testFloatTypeDefaultValue() {
+        Float defValue = floatType.createDefaultValue();
+
+        assertEquals(defValue, Float.valueOf(0));
+    }
+
+    @Test
+    public void testFloatTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(floatType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(floatType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(floatType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testFloatTypeGetNormalizedValue() {
+        assertNull(floatType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Float normalizedValue = floatType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Float.valueOf(1), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            Float normalizedValue = floatType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Float.valueOf(-1), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(floatType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testFloatTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(floatType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(floatType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(floatType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 1, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java
new file mode 100644
index 0000000..f6f6041
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java
@@ -0,0 +1,115 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasIntType;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasIntType {
+    private final AtlasIntType intType = new AtlasIntType();
+
+    private final Object[] validValues = {
+        null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1),
+        Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1",
+    };
+
+    private final Object[] negativeValues = {
+        Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1),
+        Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1",
+    };
+
+    private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", };
+
+
+    @Test
+    public void testIntTypeDefaultValue() {
+        Integer defValue = intType.createDefaultValue();
+
+        assertEquals(defValue, Integer.valueOf(0));
+    }
+
+    @Test
+    public void testIntTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(intType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(intType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(intType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testIntTypeGetNormalizedValue() {
+        assertNull(intType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Integer normalizedValue = intType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Integer.valueOf(1), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            Integer normalizedValue = intType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Integer.valueOf(-1), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(intType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testIntTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(intType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(intType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(intType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 1, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java
new file mode 100644
index 0000000..b9fb089
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java
@@ -0,0 +1,115 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasLongType;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasLongType {
+    private final AtlasLongType longType = new AtlasLongType();
+
+    private final Object[] validValues = {
+        null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1),
+        Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1",
+    };
+
+    private final Object[] negativeValues = {
+        Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1),
+        Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1",
+    };
+
+    private final Object[] invalidValues  = { "", "12ab", "abcd", "-12ab", };
+
+
+    @Test
+    public void testLongTypeDefaultValue() {
+        Long defValue = longType.createDefaultValue();
+
+        assertEquals(defValue, Long.valueOf(0));
+    }
+
+    @Test
+    public void testLongTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(longType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(longType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(longType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testLongTypeGetNormalizedValue() {
+        assertNull(longType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Long normalizedValue = longType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Long.valueOf(1), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            Long normalizedValue = longType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Long.valueOf(-1), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(longType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testLongTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(longType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(longType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(longType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 1, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasMapType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasMapType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasMapType.java
new file mode 100644
index 0000000..6f75d54
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasMapType.java
@@ -0,0 +1,116 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasIntType;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasMapType {
+    private final AtlasMapType intIntMapType = new AtlasMapType(new AtlasIntType(), new AtlasIntType());
+    private final Object[]     validValues;
+    private final Object[]     invalidValues;
+
+    {
+        Map<String, Integer>  strIntMap     = new HashMap<String, Integer>();
+        Map<String, Double>   strDoubleMap  = new HashMap<String, Double>();
+        Map<String, String>   strStringMap  = new HashMap<String, String>();
+        Map<Integer, Integer> intIntMap     = new HashMap<Integer, Integer>();
+        Map<Object, Object>   objObjMap     = new HashMap<Object, Object>();
+        Map<Object, Object>   invObjObjMap1 = new HashMap<Object, Object>();
+        Map<Object, Object>   invObjObjMap2 = new HashMap<Object, Object>();
+
+        for (int i = 0; i < 10; i++) {
+            strIntMap.put(Integer.toString(i), i);
+            strDoubleMap.put(Integer.toString(i), Double.valueOf(i));
+            strStringMap.put(Integer.toString(i), Integer.toString(i));
+            intIntMap.put(i, i);
+            objObjMap.put(i, i);
+        }
+
+        invObjObjMap1.put("xyz", "123"); // invalid key
+        invObjObjMap2.put("123", "xyz"); // invalid value
+
+        validValues = new Object[] {
+            null, new HashMap<String, Integer>(), new HashMap<Object, Object>(), strIntMap, strDoubleMap, strStringMap,
+            intIntMap, objObjMap,
+        };
+
+        invalidValues = new Object[] { invObjObjMap1, invObjObjMap2, };
+    }
+
+
+    @Test
+    public void testMapTypeDefaultValue() {
+        Map<Object, Object> defValue = intIntMapType.createDefaultValue();
+
+        assertEquals(defValue.size(), 1);
+    }
+
+    @Test
+    public void testMapTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(intIntMapType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(intIntMapType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testMapTypeGetNormalizedValue() {
+        assertNull(intIntMapType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Map<Object, Object> normalizedValue = intIntMapType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(intIntMapType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testMapTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(intIntMapType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(intIntMapType.validateValue(value, "testObj", messages));
+            assertTrue(messages.size() > 0, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasObjectIdType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasObjectIdType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasObjectIdType.java
new file mode 100644
index 0000000..61f9146
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasObjectIdType.java
@@ -0,0 +1,122 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.model.instance.AtlasObjectId;
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasObjectIdType;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasObjectIdType {
+    private final AtlasObjectIdType objectIdType = new AtlasObjectIdType();
+    private final Object[] validValues;
+    private final Object[] invalidValues;
+
+    {
+        Map<String, String> objectId1 = new HashMap<String, String>();
+        Map<Object, Object> objectId2 = new HashMap<Object, Object>();
+        Map<Object, Object> objectId3 = new HashMap<Object, Object>();
+        Map<Object, Object> objectId4 = new HashMap<Object, Object>();
+        Map<Object, Object> objectId5 = new HashMap<Object, Object>();
+
+        objectId1.put(AtlasObjectId.KEY_TYPENAME, "testType");
+        objectId1.put(AtlasObjectId.KEY_GUID, "guid-1234");
+        objectId2.put(AtlasObjectId.KEY_TYPENAME, "testType");
+        objectId2.put(AtlasObjectId.KEY_GUID, 1234);
+        objectId3.put(AtlasObjectId.KEY_TYPENAME, "testType"); // no guid
+        objectId4.put(AtlasObjectId.KEY_GUID, "guid-1234");    // no typeName
+        objectId4.put(AtlasObjectId.KEY_TYPENAME + "-invalid", "testType");
+        objectId5.put(AtlasObjectId.KEY_GUID + "-invalid", "guid-1234");
+
+
+        validValues = new Object[] {
+            null, objectId1, objectId2, new AtlasObjectId(), new AtlasObjectId("testType", "guid-1234"), };
+
+        invalidValues = new Object[] {
+            objectId3, objectId4, objectId5, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1),
+            Long.valueOf(1L), Float.valueOf(1), Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1",
+            "", "12ab", "abcd", "-12ab",
+        };
+    }
+
+    @Test
+    public void testObjectIdTypeDefaultValue() {
+        AtlasObjectId defValue = objectIdType.createDefaultValue();
+
+        assertNotNull(defValue);
+    }
+
+    @Test
+    public void testObjectIdTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(objectIdType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(objectIdType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testObjectIdTypeGetNormalizedValue() {
+        assertNull(objectIdType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            AtlasObjectId normalizedValue = objectIdType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+
+            if (value instanceof AtlasObjectId) {
+                assertEquals(normalizedValue, value, "value=" + value);
+            } else if (value instanceof Map) {
+                assertEquals(normalizedValue.getTypeName(), ((Map)value).get(AtlasObjectId.KEY_TYPENAME).toString(),
+                             "value=" + value);
+                assertEquals(normalizedValue.getGuid(), ((Map)value).get(AtlasObjectId.KEY_GUID).toString(),
+                             "value=" + value);
+            }
+        }
+    }
+
+    @Test
+    public void testObjectIdTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(objectIdType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(objectIdType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 1, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java
new file mode 100644
index 0000000..a266305
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java
@@ -0,0 +1,115 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasShortType;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasShortType {
+    private final AtlasShortType shortType = new AtlasShortType();
+
+    private final Object[] validValues = {
+        null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1),
+        Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1",
+    };
+
+    private final Object[] negativeValues = {
+        Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1),
+        Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1",
+    };
+
+    private final Object[] invalidValues  = { "", "12ab", "abcd", "-12ab", };
+
+
+    @Test
+    public void testShortTypeDefaultValue() {
+        Short defValue = shortType.createDefaultValue();
+
+        assertEquals(defValue, Short.valueOf((short)0));
+    }
+
+    @Test
+    public void testShortTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(shortType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(shortType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(shortType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testShortTypeGetNormalizedValue() {
+        assertNull(shortType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Short normalizedValue = shortType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Short.valueOf((short)1), "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            Short normalizedValue = shortType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, Short.valueOf((short)-1), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(shortType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testShortTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(shortType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : negativeValues) {
+            assertTrue(shortType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(shortType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 1, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasStringType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasStringType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasStringType.java
new file mode 100644
index 0000000..c171d98
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasStringType.java
@@ -0,0 +1,90 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import org.apache.atlas.type.AtlasBuiltInTypes.AtlasStringType;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasStringType {
+    private final AtlasStringType stringType = new AtlasStringType();
+
+    private final Object[] validValues = {
+        null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1),
+        Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", "", "12ab", "abcd", "-12ab",
+    };
+
+    private final Object[] invalidValues = { };
+
+
+    @Test
+    public void testStringTypeDefaultValue() {
+        String defValue = stringType.createDefaultValue();
+
+        assertEquals(defValue, "");
+    }
+
+    @Test
+    public void testStringTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(stringType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(stringType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testStringTypeGetNormalizedValue() {
+        assertNull(stringType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            String normalizedValue = stringType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+            assertEquals(normalizedValue, value.toString(), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testStringTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(stringType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(stringType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 1, "value=" + value);
+            messages.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java
----------------------------------------------------------------------
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java
new file mode 100644
index 0000000..1a15232
--- /dev/null
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java
@@ -0,0 +1,183 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.type;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+
+import org.apache.atlas.exception.AtlasBaseException;
+import org.apache.atlas.model.ModelTestUtil;
+import org.apache.atlas.model.instance.AtlasStruct;
+import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_INT;
+import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_DATE;
+import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_BIGINTEGER;
+
+import org.apache.atlas.model.typedef.AtlasStructDef;
+import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef;
+import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef.Cardinality;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.*;
+
+
+public class TestAtlasStructType {
+    private static final String MULTI_VAL_ATTR_NAME_MIN_MAX = "multiValMinMax";
+    private static final String MULTI_VAL_ATTR_NAME_MIN     = "multiValMin";
+    private static final String MULTI_VAL_ATTR_NAME_MAX     = "multiValMax";
+    private static final int    MULTI_VAL_ATTR_MIN_COUNT    = 2;
+    private static final int    MULTI_VAL_ATTR_MAX_COUNT    = 5;
+
+    private final AtlasStructType structType;
+    private final List<Object>    validValues;
+    private final List<Object>    invalidValues;
+
+    {
+        AtlasAttributeDef multiValuedAttribMinMax = new AtlasAttributeDef(MULTI_VAL_ATTR_NAME_MIN_MAX, ATLAS_TYPE_INT);
+        AtlasAttributeDef multiValuedAttribMin    = new AtlasAttributeDef(MULTI_VAL_ATTR_NAME_MIN, ATLAS_TYPE_INT);
+        AtlasAttributeDef multiValuedAttribMax    = new AtlasAttributeDef(MULTI_VAL_ATTR_NAME_MAX, ATLAS_TYPE_INT);
+
+        multiValuedAttribMinMax.setCardinality(Cardinality.LIST);
+        multiValuedAttribMinMax.setValuesMinCount(MULTI_VAL_ATTR_MIN_COUNT);
+        multiValuedAttribMinMax.setValuesMaxCount(MULTI_VAL_ATTR_MAX_COUNT);
+
+        multiValuedAttribMinMax.setCardinality(Cardinality.SET);
+        multiValuedAttribMin.setValuesMinCount(MULTI_VAL_ATTR_MIN_COUNT);
+
+        multiValuedAttribMinMax.setCardinality(Cardinality.LIST);
+        multiValuedAttribMax.setValuesMaxCount(MULTI_VAL_ATTR_MAX_COUNT);
+
+        AtlasStructDef structDef = ModelTestUtil.newStructDef();
+
+        structDef.addAttribute(multiValuedAttribMinMax);
+        structDef.addAttribute(multiValuedAttribMin);
+        structDef.addAttribute(multiValuedAttribMax);
+
+        structType    = getStructType(structDef);
+        validValues   = new ArrayList<Object>();
+        invalidValues = new ArrayList<Object>();
+
+        AtlasStruct invalidValue1 = structType.createDefaultValue();
+        AtlasStruct invalidValue2 = structType.createDefaultValue();
+        AtlasStruct invalidValue3 = structType.createDefaultValue();
+        AtlasStruct invalidValue4 = structType.createDefaultValue();
+        AtlasStruct invalidValue5 = structType.createDefaultValue();
+        AtlasStruct invalidValue6 = structType.createDefaultValue();
+        AtlasStruct invalidValue7 = structType.createDefaultValue();
+
+        // invalid value for int
+        invalidValue1.setAttribute(ModelTestUtil.getDefaultAttributeName(ATLAS_TYPE_INT), "xyz");
+
+        // invalid value for date
+        invalidValue2.setAttribute(ModelTestUtil.getDefaultAttributeName(ATLAS_TYPE_DATE), "xyz");
+
+        // invalid value for bigint
+        invalidValue3.setAttribute(ModelTestUtil.getDefaultAttributeName(ATLAS_TYPE_BIGINTEGER), "xyz");
+
+        // minCount is less than required
+        invalidValue4.setAttribute(MULTI_VAL_ATTR_NAME_MIN_MAX, new Integer[] { 1 });
+
+        // maxCount is more than allowed
+        invalidValue5.setAttribute(MULTI_VAL_ATTR_NAME_MIN_MAX, new Integer[] { 1, 2, 3, 4, 5, 6 });
+
+        // minCount is less than required
+        invalidValue6.setAttribute(MULTI_VAL_ATTR_NAME_MIN, new Integer[] { });
+
+        // maxCount is more than allowed
+        invalidValue7.setAttribute(MULTI_VAL_ATTR_NAME_MAX, new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
+
+        validValues.add(null);
+        validValues.add(structType.createDefaultValue());
+        validValues.add(structType.createDefaultValue().getAttributes()); // Map<String, Object>
+        invalidValues.add(invalidValue1);
+        invalidValues.add(invalidValue2);
+        invalidValues.add(invalidValue3);
+        invalidValues.add(invalidValue4);
+        invalidValues.add(invalidValue5);
+        invalidValues.add(invalidValue6);
+        invalidValues.add(invalidValue7);
+        invalidValues.add(new AtlasStruct());             // no values for mandatory attributes
+        invalidValues.add(new HashMap<Object, Object>()); // no values for mandatory attributes
+        invalidValues.add(1);               // incorrect datatype
+        invalidValues.add(new HashSet());   // incorrect datatype
+        invalidValues.add(new ArrayList()); // incorrect datatype
+        invalidValues.add(new String[] {}); // incorrect datatype
+    }
+
+    @Test
+    public void testStructTypeDefaultValue() {
+        AtlasStruct defValue = structType.createDefaultValue();
+
+        assertNotNull(defValue);
+        assertEquals(defValue.getTypeName(), structType.getTypeName());
+    }
+
+    @Test
+    public void testStructTypeIsValidValue() {
+        for (Object value : validValues) {
+            assertTrue(structType.isValidValue(value), "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(structType.isValidValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testStructTypeGetNormalizedValue() {
+        assertNull(structType.getNormalizedValue(null), "value=" + null);
+
+        for (Object value : validValues) {
+            if (value == null) {
+                continue;
+            }
+
+            Object normalizedValue = structType.getNormalizedValue(value);
+
+            assertNotNull(normalizedValue, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertNull(structType.getNormalizedValue(value), "value=" + value);
+        }
+    }
+
+    @Test
+    public void testStructTypeValidateValue() {
+        List<String> messages = new ArrayList<String>();
+        for (Object value : validValues) {
+            assertTrue(structType.validateValue(value, "testObj", messages));
+            assertEquals(messages.size(), 0, "value=" + value);
+        }
+
+        for (Object value : invalidValues) {
+            assertFalse(structType.validateValue(value, "testObj", messages));
+            assertTrue(messages.size() > 0, "value=" + value);
+            messages.clear();
+        }
+    }
+
+    private static AtlasStructType getStructType(AtlasStructDef structDef) {
+        try {
+            return new AtlasStructType(structDef, ModelTestUtil.getTypesRegistry());
+        } catch (AtlasBaseException excp) {
+            return null;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index ac5b042..5f1285a 100755
--- a/pom.xml
+++ b/pom.xml
@@ -429,6 +429,7 @@
         <javax.servlet.version>3.1.0</javax.servlet.version>
         <!-- Needed for hooks -->
         <aopalliance.version>1.0</aopalliance.version>
+        <codehaus.jackson.version>1.9.13</codehaus.jackson.version>
         <commons-conf.version>1.10</commons-conf.version>
         <commons-collections.version>3.2.2</commons-collections.version>
         <commons-logging.version>1.1.3</commons-logging.version>
@@ -501,6 +502,7 @@
     </profiles>
 
     <modules>
+        <module>intg</module>
         <module>common</module>
         <module>typesystem</module>
         <module>server-api</module>
@@ -999,6 +1001,12 @@
             <!--  atlas modules -->
             <dependency>
                 <groupId>org.apache.atlas</groupId>
+                <artifactId>atlas-intg</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.apache.atlas</groupId>
                 <artifactId>atlas-typesystem</artifactId>
                 <version>${project.version}</version>
             </dependency>

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/release-log.txt
----------------------------------------------------------------------
diff --git a/release-log.txt b/release-log.txt
index 9e185c7..85ceaa4 100644
--- a/release-log.txt
+++ b/release-log.txt
@@ -9,6 +9,7 @@ ATLAS-1060 Add composite indexes for exact match performance improvements for al
 ATLAS-1127 Modify creation and modification timestamps to Date instead of Long(sumasai)
 
 ALL CHANGES:
+ATLAS-1171 Structured, high-level public APIs (mneethiraj via shwethags)
 ATLAS-247 Hive Column level lineage (rhbutani,svimal2106 via shwethags)
 ATLAS-1184 ReservedTypesRegistrar checks for existence of 1st class type (svimal2106 via shwethags)
 ATLAS-1199 Atlas UI not loading after fresh build due to jquery-asBreadcrumbs plugin upgrade (kevalbhatt via shwethags)

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/src/build/checkstyle.xml
----------------------------------------------------------------------
diff --git a/src/build/checkstyle.xml b/src/build/checkstyle.xml
index b7b7711..5442317 100755
--- a/src/build/checkstyle.xml
+++ b/src/build/checkstyle.xml
@@ -115,7 +115,9 @@
             <property name="max" value="120"/>
         </module>
         <module name="MethodLength"/>
-        <module name="ParameterNumber"/>
+        <module name="ParameterNumber">
+            <property name="tokens" value="METHOD_DEF"/>
+        </module>
         <module name="OuterTypeNumber"/>
 
         <!-- Checks for whitespace                               -->

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/webapp/pom.xml
----------------------------------------------------------------------
diff --git a/webapp/pom.xml b/webapp/pom.xml
index 5ef1a7f..8fe4b9b 100755
--- a/webapp/pom.xml
+++ b/webapp/pom.xml
@@ -125,6 +125,11 @@
         </dependency>
 
         <dependency>
+            <groupId>org.apache.atlas</groupId>
+            <artifactId>atlas-intg</artifactId>
+        </dependency>
+
+        <dependency>
             <groupId>org.apache.hadoop</groupId>
             <artifactId>hadoop-common</artifactId>
         </dependency>

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/webapp/src/main/java/org/apache/atlas/web/rest/TypesREST.java
----------------------------------------------------------------------
diff --git a/webapp/src/main/java/org/apache/atlas/web/rest/TypesREST.java b/webapp/src/main/java/org/apache/atlas/web/rest/TypesREST.java
new file mode 100644
index 0000000..42cfd42
--- /dev/null
+++ b/webapp/src/main/java/org/apache/atlas/web/rest/TypesREST.java
@@ -0,0 +1,371 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.web.rest;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Context;
+
+import org.apache.atlas.api.PList;
+import org.apache.atlas.api.SearchFilter;
+import org.apache.atlas.model.typedef.AtlasClassificationDef;
+import org.apache.atlas.model.typedef.AtlasEntityDef;
+import org.apache.atlas.model.typedef.AtlasEnumDef;
+import org.apache.atlas.model.typedef.AtlasStructDef;
+import org.apache.atlas.web.util.Servlets;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+@Path("types")
+public class TypesREST {
+    private static final Logger LOG = LoggerFactory.getLogger(TypesREST.class);
+
+    @POST
+    @Path("/enumdef")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEnumDef createEnumDef(AtlasEnumDef enumDef) throws Exception {
+        AtlasEnumDef ret = null;
+
+        // TODO: ret = store.createEnumDef()
+
+        return ret;
+    }
+
+    @GET
+    @Path("/enumdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEnumDef getEnumDefByName(@PathParam("name") String name) throws Exception {
+        AtlasEnumDef ret = null;
+
+        // TODO: ret = store.getEnumDefByName(name)
+
+        return ret;
+    }
+
+    @GET
+    @Path("/enumdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEnumDef getEnumDefByGuid(@PathParam("guid") String guid) throws Exception {
+        AtlasEnumDef ret = null;
+
+        // TODO: ret = store.getEnumDefByGuid(guid)
+
+        return ret;
+    }
+
+    @PUT
+    @Path("/enumdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEnumDef updateEnumDefByName(@PathParam("name") String name, AtlasEnumDef enumDef) throws Exception {
+        AtlasEnumDef ret = null;
+
+        // TODO: ret = store.updateEnumDefByName(name, enumDef)
+
+        return ret;
+    }
+
+    @PUT
+    @Path("/enumdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEnumDef updateEnumDefByGuid(@PathParam("guid") String guid, AtlasEnumDef enumDef) throws Exception {
+        AtlasEnumDef ret = null;
+
+        // TODO: ret = store.updateEnumDefByGuid(guid, enumDef)
+
+        return ret;
+    }
+
+    @DELETE
+    @Path("/enumdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteEnumDefByName(@PathParam("name") String name) throws Exception {
+        // TODO: store.deleteEnumDefByName(name)
+    }
+
+    @DELETE
+    @Path("/enumdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteEnumDefByGuid(@PathParam("guid") String guid) throws Exception {
+        // TODO: store.deleteEnumDefByGuid(guid)
+    }
+
+    @GET
+    @Path("/enumdef")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public PList<AtlasEnumDef> searchEnumDefs(@Context HttpServletRequest request) throws Exception {
+        PList<AtlasEnumDef> ret = null;
+
+        // TODO: SearchFilter filter = getSearchFilter(request);
+        // TODO: ret = store.searchEnumDefs(filter);
+
+        return ret;
+    }
+
+
+    @POST
+    @Path("/structdef")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasStructDef createStructDef(AtlasStructDef structDef) throws Exception {
+        AtlasStructDef ret = null;
+
+        // TODO: ret = store.createStructDef()
+
+        return ret;
+    }
+
+    @GET
+    @Path("/structdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasStructDef getStructDefByName(@PathParam("name") String name) throws Exception {
+        AtlasStructDef ret = null;
+
+        // TODO: ret = store.getStructDefByName(name)
+
+        return ret;
+    }
+
+    @GET
+    @Path("/structdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasStructDef getStructDefByGuid(@PathParam("guid") String guid) throws Exception {
+        AtlasStructDef ret = null;
+
+        // TODO: ret = store.getStructDefByGuid(guid)
+
+        return ret;
+    }
+
+    @PUT
+    @Path("/structdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasStructDef updateStructDefByName(@PathParam("name") String name, AtlasStructDef structDef) throws Exception {
+        AtlasStructDef ret = null;
+
+        // TODO: ret = store.updateStructDefByName(name, structDef)
+
+        return ret;
+    }
+
+    @PUT
+    @Path("/structdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasStructDef updateStructDefByGuid(@PathParam("guid") String guid, AtlasStructDef structDef) throws Exception {
+        AtlasStructDef ret = null;
+
+        // TODO: ret = store.updateStructDefByGuid(guid, structDef)
+
+        return ret;
+    }
+
+    @DELETE
+    @Path("/structdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteStructDefByName(@PathParam("name") String name) throws Exception {
+        // TODO: store.deleteStructDefByName(name)
+    }
+
+    @DELETE
+    @Path("/structdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteStructDefByGuid(@PathParam("guid") String guid) throws Exception {
+        // TODO: store.deleteStructDefByGuid(guid)
+    }
+
+    @GET
+    @Path("/structdef")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public PList<AtlasStructDef> searchStructDefs(@Context HttpServletRequest request) throws Exception {
+        PList<AtlasStructDef> ret = null;
+
+        // TODO: SearchFilter filter = getSearchFilter(request);
+        // TODO: ret = store.searchStructDefs(filter);
+
+        return ret;
+    }
+
+
+    @POST
+    @Path("/classificationdef")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasClassificationDef createClassificationDef(AtlasClassificationDef classificationDef) throws Exception {
+        AtlasClassificationDef ret = null;
+
+        // TODO: ret = store.createClassificationDef()
+
+        return ret;
+    }
+
+    @GET
+    @Path("/classificationdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasClassificationDef getClassificationDefByName(@PathParam("name") String name) throws Exception {
+        AtlasClassificationDef ret = null;
+
+        // TODO: ret = store.getClassificationDefByName(name)
+
+        return ret;
+    }
+
+    @GET
+    @Path("/classificationdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasClassificationDef getClassificationDefByGuid(@PathParam("guid") String guid) throws Exception {
+        AtlasClassificationDef ret = null;
+
+        // TODO: ret = store.getClassificationDefByGuid(guid)
+
+        return ret;
+    }
+
+    @PUT
+    @Path("/classificationdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasClassificationDef updateClassificationDefByName(@PathParam("name") String name, AtlasClassificationDef classificationDef) throws Exception {
+        AtlasClassificationDef ret = null;
+
+        // TODO: ret = store.updateClassificationDefByName(name, classificationDef)
+
+        return ret;
+    }
+
+    @PUT
+    @Path("/classificationdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasClassificationDef updateClassificationDefByGuid(@PathParam("guid") String guid, AtlasClassificationDef classificationDef) throws Exception {
+        AtlasClassificationDef ret = null;
+
+        // TODO: ret = store.updateClassificationDefByGuid(guid, classificationDef)
+
+        return ret;
+    }
+
+    @DELETE
+    @Path("/classificationdef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteClassificationDefByName(@PathParam("name") String name) throws Exception {
+        // TODO: store.deleteClassificationDefByName(name)
+    }
+
+    @DELETE
+    @Path("/classificationdef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteClassificationDefByGuid(@PathParam("guid") String guid) throws Exception {
+        // TODO: store.deleteClassificationDefByGuid(guid)
+    }
+
+    @GET
+    @Path("/classificationdef")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public PList<AtlasClassificationDef> searchClassificationDefs(SearchFilter filter) throws Exception {
+        PList<AtlasClassificationDef> ret = null;
+
+        // TODO: SearchFilter filter = getSearchFilter(request);
+        // TODO: ret = store.searchClassificationDefs(filter);
+
+        return ret;
+    }
+
+
+    @POST
+    @Path("/entitydef")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEntityDef createEntityDef(AtlasEntityDef entityDef) throws Exception {
+        AtlasEntityDef ret = null;
+
+        // TODO: ret = store.createEntityDef()
+
+        return ret;
+    }
+
+    @GET
+    @Path("/entitydef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEntityDef getEntityDefByName(@PathParam("name") String name) throws Exception {
+        AtlasEntityDef ret = null;
+
+        // TODO: ret = store.getEntityDefByName(name)
+
+        return ret;
+    }
+
+    @GET
+    @Path("/entitydef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEntityDef getEntityDefByIdByGuid(@PathParam("guid") String guid) throws Exception {
+        AtlasEntityDef ret = null;
+
+        // TODO: ret = store.getEntityDefByGuid(guid)
+
+        return ret;
+    }
+
+    @PUT
+    @Path("/entitydef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEntityDef updateEntityDefByName(@PathParam("name") String name, AtlasEntityDef entityDef) throws Exception {
+        AtlasEntityDef ret = null;
+
+        // TODO: ret = store.updateEntityDefByName(name, entityDef)
+
+        return ret;
+    }
+
+    @PUT
+    @Path("/entitydef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public AtlasEntityDef updateEntityDefByGuid(@PathParam("guid") String guid, AtlasEntityDef entityDef) throws Exception {
+        AtlasEntityDef ret = null;
+
+        // TODO: ret = store.updateEntityDefByGuid(guid, entityDef)
+
+        return ret;
+    }
+
+    @DELETE
+    @Path("/entitydef/name/{name}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteEntityDef(@PathParam("name") String name) throws Exception {
+        // TODO: store.deleteEntityDefByName(name)
+    }
+
+    @DELETE
+    @Path("/entitydef/guid/{guid}")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public void deleteEntityDefByGuid(@PathParam("guid") String guid) throws Exception {
+        // TODO: store.deleteEntityDefByGuid(guid)
+    }
+
+    @GET
+    @Path("/entitydef")
+    @Produces(Servlets.JSON_MEDIA_TYPE)
+    public PList<AtlasEntityDef> searchEntityDefs(SearchFilter filter) throws Exception {
+        PList<AtlasEntityDef> ret = null;
+
+        // TODO: SearchFilter filter = getSearchFilter(request);
+        // TODO: ret = store.searchEntityDefs(filter);
+
+        return ret;
+    }
+}


Mime
View raw message