diff --git a/intg/src/main/java/org/apache/atlas/type/AtlasStructType.java b/intg/src/main/java/org/apache/atlas/type/AtlasStructType.java
index 591b316..ffbe9e7 100644
--- a/intg/src/main/java/org/apache/atlas/type/AtlasStructType.java
+++ b/intg/src/main/java/org/apache/atlas/type/AtlasStructType.java
@@ -1075,17 +1075,30 @@
         }
 
         public static boolean hastokenizeChar(String value) {
-            if (value != null) {
+            if (StringUtils.isNotEmpty(value)) {
                 for (int i = 0; i < value.length(); i++) {
                     if (hastokenizeChar(value, i)) {
                         return true;
+                    } else if (hasCJKChar(value,i)) {
+                        return true;
                     }
                 }
             }
-
             return false;
         }
 
+        private static boolean hasCJKChar(String value,int i){
+            char ch = value.charAt(i);
+            Character.UnicodeBlock block = Character.UnicodeBlock.of(ch);
+
+            if (Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS.equals(block) ||
+                    Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS.equals(block) ||
+                    Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A.equals(block) ||
+                    Character.UnicodeBlock.HIRAGANA.equals(block)) {
+                return true;
+            }
+            return false;
+        }
 
         private static boolean hastokenizeChar(String value, int i) {
             char c = value.charAt(i);
diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java
index f117fb3..f292f00 100644
--- a/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java
+++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java
@@ -49,6 +49,8 @@
     private final AtlasStructType structType;
     private final List<Object>    validValues;
     private final List<Object>    invalidValues;
+    private final List<String>    tokenizedValue;
+    private final List<String>    nonTokenizedValue;
 
     {
         AtlasAttributeDef multiValuedAttribMinMax = new AtlasAttributeDef();
@@ -126,6 +128,31 @@
         invalidValues.add(new HashSet());   // incorrect datatype
         invalidValues.add(new ArrayList()); // incorrect datatype
         invalidValues.add(new String[] {}); // incorrect datatype
+
+        tokenizedValue = new ArrayList<>();
+
+        tokenizedValue.add("test[data"); //added special char [
+        tokenizedValue.add("test]data"); //added special char ]
+        tokenizedValue.add("狗"); //single char chinese data
+        tokenizedValue.add("数据"); //mutiple char chinese data
+        tokenizedValue.add("test data"); //english words with space
+        tokenizedValue.add("testdata "); //space after testdata
+        tokenizedValue.add("私は日本語を話します"); //japanese word
+        tokenizedValue.add("元帳"); //japanese ledger char
+        tokenizedValue.add("mydata&"); //added special char &
+        tokenizedValue.add("test.1data");
+        tokenizedValue.add("test:1data");
+
+        nonTokenizedValue = new ArrayList<>();
+
+        nonTokenizedValue.add("test.data");
+        nonTokenizedValue.add("test:data");
+        nonTokenizedValue.add("test_data");
+        nonTokenizedValue.add("test:");
+        nonTokenizedValue.add("test.");
+        nonTokenizedValue.add("test_");
+        nonTokenizedValue.add("レシート");
+        nonTokenizedValue.add("test");
     }
 
     @Test
@@ -199,6 +226,16 @@
         }
     }
 
+    @Test
+    public void testTokenizeChar() {
+        for (String valid : tokenizedValue) {
+            assertTrue(AtlasStructType.AtlasAttribute.hastokenizeChar(valid));
+        }
+        for (String invalid : nonTokenizedValue) {
+            assertFalse(AtlasStructType.AtlasAttribute.hastokenizeChar(invalid));
+        }
+    }
+
     private static AtlasStructType getStructType(AtlasStructDef structDef) {
         try {
             return new AtlasStructType(structDef, ModelTestUtil.getTypesRegistry());
diff --git a/repository/src/main/java/org/apache/atlas/discovery/EntityDiscoveryService.java b/repository/src/main/java/org/apache/atlas/discovery/EntityDiscoveryService.java
index 9be6517..dc3acf6 100644
--- a/repository/src/main/java/org/apache/atlas/discovery/EntityDiscoveryService.java
+++ b/repository/src/main/java/org/apache/atlas/discovery/EntityDiscoveryService.java
@@ -466,6 +466,16 @@
     @Override
     @GraphTransaction
     public AtlasSearchResult searchWithParameters(SearchParameters searchParameters) throws AtlasBaseException {
+        String query = searchParameters.getQuery();
+
+        if (StringUtils.isNotEmpty(query)) {
+
+            String modifiedString = StringUtils.strip(query, "*");
+
+            if (AtlasStructType.AtlasAttribute.hastokenizeChar(modifiedString)) {
+                searchParameters.setQuery(modifiedString);
+            }
+        }
         return searchWithSearchContext(new SearchContext(searchParameters, typeRegistry, graph, indexer.getVertexIndexKeys()));
     }
 
diff --git a/repository/src/main/java/org/apache/atlas/repository/store/graph/v2/EntityGraphMapper.java b/repository/src/main/java/org/apache/atlas/repository/store/graph/v2/EntityGraphMapper.java
index 01b88eb..77ab99a 100644
--- a/repository/src/main/java/org/apache/atlas/repository/store/graph/v2/EntityGraphMapper.java
+++ b/repository/src/main/java/org/apache/atlas/repository/store/graph/v2/EntityGraphMapper.java
@@ -142,8 +142,8 @@
     private static final String  CUSTOM_ATTRIBUTE_KEY_SPECIAL_PREFIX = AtlasConfiguration.CUSTOM_ATTRIBUTE_KEY_SPECIAL_PREFIX.getString();
 
     private static final String  CLASSIFICATION_NAME_DELIMITER     = "|";
-    private static final Pattern CUSTOM_ATTRIBUTE_KEY_REGEX        = Pattern.compile("^[a-zA-Z0-9_-]*$");
-    private static final Pattern LABEL_REGEX                       = Pattern.compile("^[a-zA-Z0-9_-]*$");
+    private static final Pattern CUSTOM_ATTRIBUTE_KEY_REGEX        = Pattern.compile("^[\u2E80-\u2FD5\u3190-\u319f\u3400-\u4DBF\u4E00-\u9FCC\uF900-\uFAADa-zA-Z0-9_-]*$");
+    private static final Pattern LABEL_REGEX                       = Pattern.compile("^[\u2E80-\u2FD5\u3190-\u319f\u3400-\u4DBF\u4E00-\u9FCC\uF900-\uFAADa-zA-Z0-9_-]*$");
     private static final int     CUSTOM_ATTRIBUTE_KEY_MAX_LENGTH   = AtlasConfiguration.CUSTOM_ATTRIBUTE_KEY_MAX_LENGTH.getInt();
     private static final int     CUSTOM_ATTRIBUTE_VALUE_MAX_LENGTH = AtlasConfiguration.CUSTOM_ATTRIBUTE_VALUE_MAX_LENGTH.getInt();
 
diff --git a/repository/src/test/java/org/apache/atlas/BasicTestSetup.java b/repository/src/test/java/org/apache/atlas/BasicTestSetup.java
index 593f8c1..88ca39c 100644
--- a/repository/src/test/java/org/apache/atlas/BasicTestSetup.java
+++ b/repository/src/test/java/org/apache/atlas/BasicTestSetup.java
@@ -56,6 +56,7 @@
     private static final   String STORAGE_DESC_TYPE = "hive_storagedesc";
     private static final   String VIEW_TYPE         = "hive_process";
     protected static final String DATASET_SUBTYPE   = "Asset";
+    protected static final String HDFS_PATH         = "hdfs_path";
 
     //Classification type //
     public static final String DIMENSION_CLASSIFICATION    = "Dimension";
@@ -94,6 +95,7 @@
     protected void setupTestData() {
         loadBaseModels();
         loadHiveDataset();
+        loadFsDataset();
         loadEmployeeDataset();
         assignGlossary();
     }
@@ -148,6 +150,18 @@
         }
     }
 
+    protected void loadFsDataset() {
+        if (!baseLoaded) {
+            loadBaseModels();
+        }
+
+        try {
+            loadModelFromJson("1000-Hadoop/1020-fs_model.json", typeDefStore, typeRegistry);
+        } catch (IOException | AtlasBaseException e) {
+            fail("Fs model setup is required for test to run!");
+        }
+    }
+
     protected void loadEmployeeDataset() {
         if (!baseLoaded) {
             loadBaseModels();
@@ -342,7 +356,8 @@
                 new AtlasClassificationDef(PII_CLASSIFICATION, "PII Classification", "1.0"),
                 new AtlasClassificationDef(METRIC_CLASSIFICATION, "Metric Classification", "1.0"),
                 new AtlasClassificationDef(ETL_CLASSIFICATION, "ETL Classification", "1.0"),
-                new AtlasClassificationDef(JDBC_CLASSIFICATION, "JdbcAccess Classification", "1.0"),
+                new AtlasClassificationDef(JDBC_CLASSIFICATION, "JdbcAccess Classification", "1.0",
+                        Arrays.asList(new AtlasStructDef.AtlasAttributeDef("attr1","string"))),
                 new AtlasClassificationDef(LOGDATA_CLASSIFICATION, "LogData Classification", "1.0"),
                 new AtlasClassificationDef(DIMENSIONAL_CLASSIFICATION,"Dimensional Classification", "1.0" ,
                         Arrays.asList(new AtlasStructDef.AtlasAttributeDef("attr1","string"))));
@@ -759,4 +774,24 @@
         }
         return entities;
     }
+
+    public void addLabels(){
+
+        for(AtlasEntityHeader entity : hiveEntities.getCreatedEntities()) {
+
+            if (entity.getTypeName().equals(HIVE_TABLE_TYPE)){
+                Set<String> labels = new HashSet<>();
+                labels.add("你好");
+
+                try {
+                    entityStore.setLabels(entity.getGuid(), labels);
+
+                } catch (AtlasBaseException e) {
+                    fail("Failed to add Labels for Chinese characters to entity");
+                }
+                break;
+            }
+        }
+
+    }
 }
diff --git a/repository/src/test/java/org/apache/atlas/discovery/AtlasDiscoveryServiceTest.java b/repository/src/test/java/org/apache/atlas/discovery/AtlasDiscoveryServiceTest.java
index 282a3fd..fb94aae 100644
--- a/repository/src/test/java/org/apache/atlas/discovery/AtlasDiscoveryServiceTest.java
+++ b/repository/src/test/java/org/apache/atlas/discovery/AtlasDiscoveryServiceTest.java
@@ -42,6 +42,7 @@
 import org.testng.annotations.*;
 
 import javax.inject.Inject;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -69,6 +70,7 @@
         createDimensionalTaggedEntity("sales");
         createSpecialCharTestEntities();
         setupRelationshipTestData();
+        createJapaneseEntityWithDescription();
     }
 
     /*  TermSearchProcessor(TSP),
@@ -1047,6 +1049,78 @@
         assertEquals(sr.getRelations().size(), 4);
     }
 
+    @Test
+    public void cjkCharQuickSearch() throws AtlasBaseException {
+        addLabels();
+        String searchValue = "你";
+        int expected = 1;
+
+        QuickSearchParameters params = new QuickSearchParameters();
+        params.setQuery(searchValue);
+        params.setLimit(5);
+        params.setOffset(0);
+
+        AtlasQuickSearchResult searchResult = discoveryService.quickSearch(params);
+        assertSearchResult(searchResult.getSearchResults(), expected, searchValue);
+    }
+
+    @Test(dependsOnMethods = "cjkCharQuickSearch")
+    public void cjkCharBasicSearch() throws AtlasBaseException {
+        String searchValue = "你好";
+        int expected = 1;
+
+        SearchParameters params = new SearchParameters();
+        params.setQuery(searchValue);
+        params.setLimit(5);
+        params.setOffset(0);
+
+        AtlasSearchResult searchResult = discoveryService.searchWithParameters(params);
+        assertSearchResult(searchResult, expected, searchValue);
+    }
+
+    @Test
+    public void japaneseReceiptStarSearch() throws AtlasBaseException {
+        String searchValue = "レシート";
+        int expected = 1;
+
+        SearchParameters params = new SearchParameters();
+        params.setQuery(searchValue);
+        params.setTypeName(HDFS_PATH);
+        params.setLimit(5);
+        params.setOffset(0);
+
+        AtlasSearchResult searchResult = discoveryService.searchWithParameters(params);
+        assertSearchResult(searchResult, expected, searchValue);
+    }
+
+    @Test
+    public void japaneseLedgerSearch() throws AtlasBaseException {
+        String searchValue = "元帳";
+        int expected = 2;
+
+        SearchParameters params = new SearchParameters();
+        params.setQuery(searchValue);
+        params.setLimit(5);
+        params.setOffset(0);
+
+        AtlasSearchResult searchResult = discoveryService.searchWithParameters(params);
+        assertSearchResult(searchResult, expected, searchValue);
+    }
+    
+    @Test
+    public void japaneseLedgerStarSearch() throws AtlasBaseException {
+        String searchValue = "の台*";
+        int expected = 1;
+
+        SearchParameters params = new SearchParameters();
+        params.setQuery(searchValue);
+        params.setLimit(5);
+        params.setOffset(0);
+
+        AtlasSearchResult searchResult = discoveryService.searchWithParameters(params);
+        assertSearchResult(searchResult, expected, searchValue);
+    }
+
     private String gethiveTableSalesFactGuid() throws AtlasBaseException {
         if (salesFactGuid == null) {
             SearchParameters params = new SearchParameters();
@@ -1105,6 +1179,21 @@
         entityStore.addClassification(Arrays.asList(guid), new AtlasClassification(DIMENSIONAL_CLASSIFICATION, attr));
     }
 
+    private void createJapaneseEntityWithDescription() throws AtlasBaseException {
+        AtlasEntity entity = new AtlasEntity(HDFS_PATH);
+        entity.setAttribute("name", "元帳");
+        entity.setAttribute(AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, "レシート");
+        entity.setAttribute("path", "レシート");
+
+        entityStore.createOrUpdate(new AtlasEntityStream(new AtlasEntity.AtlasEntitiesWithExtInfo(entity)), false);
+
+        AtlasEntity entity2 = new AtlasEntity(HDFS_PATH);
+        entity2.setAttribute("name", "cjk");
+        entity2.setAttribute(AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, "の台帳");
+        entity2.setAttribute("path", "cjk");
+
+        entityStore.createOrUpdate(new AtlasEntityStream(new AtlasEntity.AtlasEntitiesWithExtInfo(entity2)), false);
+    }
 
     private void assertSearchProcessorWithoutMarker(SearchParameters params, int expected) throws AtlasBaseException {
         assertSearchProcessor(params, expected, false);
diff --git a/repository/src/test/java/org/apache/atlas/discovery/ClassificationSearchProcessorTest.java b/repository/src/test/java/org/apache/atlas/discovery/ClassificationSearchProcessorTest.java
index 121dca9..c69302a 100644
--- a/repository/src/test/java/org/apache/atlas/discovery/ClassificationSearchProcessorTest.java
+++ b/repository/src/test/java/org/apache/atlas/discovery/ClassificationSearchProcessorTest.java
@@ -64,6 +64,8 @@
     private int    dimensionTagEntities                 = 10;
     private String dimensionTagDeleteGuid;
     private String dimensionalTagGuid;
+    private String CJKGUID1;
+    private String CJKGUID2;
 
     @BeforeClass
     public void setup() throws Exception {
@@ -72,6 +74,8 @@
         setupTestData();
         createDimensionTaggedEntityAndDelete();
         createDimensionalTaggedEntityWithAttr();
+        createChineseEntityWithClassificationSingleChar();
+        createChineseEntityWithClassificationMultipleChar();
     }
 
     @Test(priority = -1)
@@ -356,6 +360,360 @@
 
     }
 
+    private void createChineseEntityWithClassificationSingleChar() throws AtlasBaseException {
+        AtlasEntity entityToDelete = new AtlasEntity(HDFS_PATH);
+        entityToDelete.setAttribute("name", "h1");
+        entityToDelete.setAttribute(AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, "h1qualified");
+        entityToDelete.setAttribute("path", "h1");
+
+        List<AtlasClassification> cls = new ArrayList<>();
+        cls.add(new AtlasClassification(JDBC_CLASSIFICATION, new HashMap<String, Object>() {{
+            put("attr1", "狗");
+        }}));
+        entityToDelete.setClassifications(cls);
+
+        //create entity
+        final EntityMutationResponse response = entityStore.createOrUpdate(new AtlasEntityStream(new AtlasEntity.AtlasEntitiesWithExtInfo(entityToDelete)), false);
+        AtlasEntityHeader entityHeader = response.getCreatedEntities().get(0);
+        CJKGUID1 = entityHeader.getGuid();
+
+    }
+
+    private void createChineseEntityWithClassificationMultipleChar() throws AtlasBaseException {
+        AtlasEntity entityToDelete = new AtlasEntity(HDFS_PATH);
+        entityToDelete.setAttribute("name", "h2");
+        entityToDelete.setAttribute(AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, "h2qualified");
+        entityToDelete.setAttribute("path", "h2");
+
+
+        List<AtlasClassification> cls = new ArrayList<>();
+        cls.add(new AtlasClassification(JDBC_CLASSIFICATION, new HashMap<String, Object>() {{
+            put("attr1", "数据");
+        }}));
+        entityToDelete.setClassifications(cls);
+
+        //create entity
+        final EntityMutationResponse response = entityStore.createOrUpdate(new AtlasEntityStream(new AtlasEntity.AtlasEntitiesWithExtInfo(entityToDelete)), false);
+        AtlasEntityHeader entityHeader = response.getCreatedEntities().get(0);
+        CJKGUID2 = entityHeader.getGuid();
+
+    }
+
+    //Equals with single char
+    @Test
+    public void searchJapaneseChineseByTagEquals() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.EQ, "狗");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID1));
+
+    }
+
+    //NEQ with single char
+    @Test
+    public void searchJapaneseChineseByTagNotEquals() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.NEQ, "狗");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID2));
+
+    }
+
+    //Contains with single char
+    @Test
+    public void searchJapaneseChineseByTagContains() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.CONTAINS, "狗");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID1));
+
+    }
+
+    //Begins with single char
+    @Test
+    public void searchJapaneseChineseByTagBeginswith() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.STARTS_WITH, "狗");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID1));
+
+    }
+
+    //ENDS with single char
+    @Test
+    public void searchJapaneseChineseByTagEndsWith() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.ENDS_WITH, "狗");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID1));
+
+    }
+
+    //ISNULL check
+    @Test
+    public void searchJapaneseChineseByTagISNULL() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.IS_NULL, "");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 2); //customer_dim_view, product_dim_view entities
+    }
+
+    //ISNOT NULL CHECK
+    @Test
+    public void searchJapaneseChineseByTagISNOTNULL() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.NOT_NULL, "狗");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 2);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID1));
+
+    }
+
+    //Equals with Multiple char
+    @Test
+    public void searchJapaneseChineseByTagEqualsMultiple() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.EQ, "数据");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID2));
+
+    }
+
+    //NEQ with Multiple char
+    @Test
+    public void searchJapaneseChineseByTagNotEqualsMultiple() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.NEQ, "数据");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID1));
+
+    }
+
+    //Contains with Multiple char
+    @Test
+    public void searchJapaneseChineseByTagContainsMultiple() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.CONTAINS, "数据");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID2));
+
+    }
+
+    //Begins with Multiple char
+    @Test
+    public void searchJapaneseChineseByTagBeginsWithMultiple() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.STARTS_WITH, "数据");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID2));
+
+    }
+
+    //ENDS with single char
+    @Test
+    public void searchJapaneseChineseByTagEndsWithMultiple() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setClassification(JDBC_CLASSIFICATION);
+        FilterCriteria filterCriteria = getSingleFilterCondition("attr1", Operator.ENDS_WITH, "数据");
+        params.setTagFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+        ClassificationSearchProcessor processor = new ClassificationSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID2));
+
+    }
+
+
     @AfterClass
     public void teardown() throws Exception {
         AtlasGraphProvider.cleanup();
diff --git a/repository/src/test/java/org/apache/atlas/discovery/EntitySearchProcessorTest.java b/repository/src/test/java/org/apache/atlas/discovery/EntitySearchProcessorTest.java
index 3f9e74d..a4edb09 100644
--- a/repository/src/test/java/org/apache/atlas/discovery/EntitySearchProcessorTest.java
+++ b/repository/src/test/java/org/apache/atlas/discovery/EntitySearchProcessorTest.java
@@ -18,18 +18,25 @@
 package org.apache.atlas.discovery;
 
 import com.google.common.collect.Sets;
+import org.apache.atlas.AtlasClient;
 import org.apache.atlas.BasicTestSetup;
 import org.apache.atlas.SortOrder;
 import org.apache.atlas.TestModules;
 import org.apache.atlas.exception.AtlasBaseException;
 import org.apache.atlas.model.discovery.SearchParameters;
+import org.apache.atlas.model.instance.AtlasClassification;
+import org.apache.atlas.model.instance.AtlasEntity;
+import org.apache.atlas.model.instance.AtlasEntityHeader;
+import org.apache.atlas.model.instance.EntityMutationResponse;
 import org.apache.atlas.repository.Constants;
 import org.apache.atlas.repository.graph.AtlasGraphProvider;
 import org.apache.atlas.repository.graph.GraphBackedSearchIndexer;
 import org.apache.atlas.repository.graphdb.AtlasGraph;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
+import org.apache.atlas.repository.store.graph.v2.AtlasEntityStream;
 import org.apache.atlas.repository.store.graph.v2.EntityGraphRetriever;
 import org.apache.atlas.type.AtlasTypeRegistry;
+import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Guice;
@@ -40,6 +47,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Calendar;
 import java.util.GregorianCalendar;
@@ -50,6 +58,7 @@
 
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
 
 @Guice(modules = TestModules.TestOnlyModule.class)
 public class EntitySearchProcessorTest extends BasicTestSetup {
@@ -65,11 +74,17 @@
     @Inject
     private EntityGraphRetriever entityRetriever;
 
+    private String CJKGUID1;
+
+    private String CJKGUID2;
+
     @BeforeClass
     public void setup() throws Exception {
         super.initialize();
 
         setupTestData();
+        createJapaneseEntityWithDescription();
+        createChineseEntityWithDescription();
     }
 
     @Inject
@@ -630,8 +645,172 @@
         List b =v2.stream().map(v3 -> v3.getProperty(Constants.GUID_PROPERTY_KEY, String.class)).collect(Collectors.toList());
 
         assertTrue(!a.stream().anyMatch(element -> b.contains(element)));
+    }
 
+    //Description EQUALS chinese multiple char
+    @Test
+    public void searchChineseDescription() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setTypeName(HDFS_PATH);
+        SearchParameters.FilterCriteria filterCriteria = getSingleFilterCondition("path", SearchParameters.Operator.EQ, "我说中文");
+        filterCriteria.getCriterion();
+        params.setEntityFilters(filterCriteria);
+        params.setLimit(20);
 
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+
+        EntitySearchProcessor processor = new EntitySearchProcessor(context);//
+        List<AtlasVertex> vertices = processor.execute();
+
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID2));
+    }
+
+    //Description contains chinese multiple char
+    @Test
+    public void searchChineseDescriptionCONTAINS() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setTypeName(HDFS_PATH);
+        SearchParameters.FilterCriteria filterCriteria = getSingleFilterCondition("path", SearchParameters.Operator.CONTAINS, "我说中文");
+        filterCriteria.getCriterion();
+        params.setEntityFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+
+        EntitySearchProcessor processor = new EntitySearchProcessor(context);//
+        List<AtlasVertex> vertices = processor.execute();
+
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID2));
+    }
+
+    //Description contains japanese
+    @Test
+    public void searchJapaneseDescription() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setTypeName(HDFS_PATH);
+        SearchParameters.FilterCriteria filterCriteria = getSingleFilterCondition("path", SearchParameters.Operator.EQ, "私は日本語を話します");
+        filterCriteria.getCriterion();
+        params.setEntityFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+
+        EntitySearchProcessor processor = new EntitySearchProcessor(context);//
+        List<AtlasVertex> vertices = processor.execute();
+
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID1));
+    }
+
+    @Test
+    public void searchWithQualifiedNameEQ() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setTypeName(HDFS_PATH);
+        SearchParameters.FilterCriteria filterCriteria = getSingleFilterCondition("qualifiedName", SearchParameters.Operator.EQ, "h3qualified");
+        filterCriteria.getCriterion();
+        params.setEntityFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+
+        EntitySearchProcessor processor = new EntitySearchProcessor(context);//
+        List<AtlasVertex> vertices = processor.execute();
+
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+        Assert.assertTrue(guids.contains(CJKGUID1));
+    }
+
+    @Test
+    public void searchWithNameBeginswith() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setTypeName(HDFS_PATH);
+        SearchParameters.FilterCriteria filterCriteria = getSingleFilterCondition("name", SearchParameters.Operator.STARTS_WITH, "hdfs");
+        filterCriteria.getCriterion();
+        params.setEntityFilters(filterCriteria);
+        params.setLimit(20);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, indexer.getVertexIndexKeys());
+
+        EntitySearchProcessor processor = new EntitySearchProcessor(context);//
+        List<AtlasVertex> vertices = processor.execute();
+
+        assertEquals(vertices.size(), 1);
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+
+        Assert.assertTrue(guids.contains(CJKGUID2));
+
+    }
+
+    private void createJapaneseEntityWithDescription() throws AtlasBaseException {
+        AtlasEntity entity = new AtlasEntity(HDFS_PATH);
+        entity.setAttribute("name", "h3");
+        entity.setAttribute(AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, "h3qualified");
+        entity.setAttribute("path", "私は日本語を話します");
+
+        List<AtlasClassification> cls = new ArrayList<>();
+        cls.add(new AtlasClassification(JDBC_CLASSIFICATION, new HashMap<String, Object>() {{
+            put("attr1", "attr1");
+        }}));
+        entity.setClassifications(cls);
+
+        //create entity
+        final EntityMutationResponse response = entityStore.createOrUpdate(new AtlasEntityStream(new AtlasEntity.AtlasEntitiesWithExtInfo(entity)), false);
+        AtlasEntityHeader entityHeader = response.getCreatedEntities().get(0);
+        CJKGUID1 = entityHeader.getGuid();
+
+    }
+
+    private void createChineseEntityWithDescription() throws AtlasBaseException {
+        AtlasEntity entity = new AtlasEntity(HDFS_PATH);
+        entity.setAttribute("name", "hdfs_chinese_test");
+        entity.setAttribute(AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, "hdfs_chinese_test_qualified");
+        entity.setAttribute("path", "我说中文");
+
+        //create entity
+        final EntityMutationResponse response = entityStore.createOrUpdate(new AtlasEntityStream(new AtlasEntity.AtlasEntitiesWithExtInfo(entity)), false);
+        AtlasEntityHeader entityHeader = response.getCreatedEntities().get(0);
+        CJKGUID2 = entityHeader.getGuid();
     }
 
 }
diff --git a/repository/src/test/java/org/apache/atlas/discovery/FreeTextSearchProcessorTest.java b/repository/src/test/java/org/apache/atlas/discovery/FreeTextSearchProcessorTest.java
index d7825a0..567b1f7 100644
--- a/repository/src/test/java/org/apache/atlas/discovery/FreeTextSearchProcessorTest.java
+++ b/repository/src/test/java/org/apache/atlas/discovery/FreeTextSearchProcessorTest.java
@@ -18,31 +18,43 @@
 package org.apache.atlas.discovery;
 
 import com.google.common.collect.Sets;
+import org.apache.atlas.AtlasClient;
 import org.apache.atlas.BasicTestSetup;
 import org.apache.atlas.SortOrder;
 import org.apache.atlas.TestModules;
 import org.apache.atlas.exception.AtlasBaseException;
 import org.apache.atlas.model.discovery.SearchParameters;
+import org.apache.atlas.model.instance.AtlasClassification;
+import org.apache.atlas.model.instance.AtlasEntity;
+import org.apache.atlas.model.instance.AtlasEntityHeader;
+import org.apache.atlas.model.instance.EntityMutationResponse;
 import org.apache.atlas.repository.graph.AtlasGraphProvider;
 import org.apache.atlas.repository.graphdb.AtlasGraph;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
+import org.apache.atlas.repository.store.graph.v2.AtlasEntityStream;
 import org.apache.atlas.repository.store.graph.v2.AtlasGraphUtilsV2;
 import org.apache.atlas.repository.store.graph.v2.EntityGraphRetriever;
 import org.apache.atlas.type.AtlasEntityType;
 import org.apache.atlas.type.AtlasTypeRegistry;
+import org.apache.commons.collections.CollectionUtils;
+import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Guice;
 import org.testng.annotations.Test;
 
 import javax.inject.Inject;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertNotEquals;
 import static org.testng.Assert.assertFalse;
 import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.fail;
 
 @Guice(modules = TestModules.TestOnlyModule.class)
 public class FreeTextSearchProcessorTest extends BasicTestSetup {
@@ -56,11 +68,14 @@
     @Inject
     private EntityGraphRetriever entityRetriever;
 
+    private String entityGUID;
+
     @BeforeClass
     public void setup() throws Exception {
         super.initialize();
 
         setupTestData();
+        createEntityWithQualifiedName();
     }
 
     @Test
@@ -162,6 +177,103 @@
         }
     }
 
+    @Test
+    public void searchQualifiedName() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setQuery("h1qualified*");
+        params.setExcludeDeletedEntities(true);
+        params.setLimit(500);
+        params.setOffset(0);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, Collections.<String>emptySet());
+        FreeTextSearchProcessor processor = new FreeTextSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+
+        Assert.assertTrue(guids.contains(entityGUID));
+
+    }
+
+    @Test
+    public void searchName() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setQuery("h1Name*");
+        params.setExcludeDeletedEntities(true);
+        params.setLimit(500);
+        params.setOffset(0);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, Collections.<String>emptySet());
+        FreeTextSearchProcessor processor = new FreeTextSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+
+        Assert.assertTrue(guids.contains(entityGUID));
+
+    }
+
+    @Test
+    public void searchNameWithStar() throws AtlasBaseException {
+        SearchParameters params = new SearchParameters();
+        params.setQuery("*h1*");
+        params.setExcludeDeletedEntities(true);
+        params.setLimit(500);
+        params.setOffset(0);
+
+        SearchContext context = new SearchContext(params, typeRegistry, graph, Collections.<String>emptySet());
+        FreeTextSearchProcessor processor = new FreeTextSearchProcessor(context);
+        List<AtlasVertex> vertices = processor.execute();
+
+        Assert.assertTrue(CollectionUtils.isNotEmpty(vertices));
+        assertEquals(vertices.size(), 1);
+
+        List<String> guids = vertices.stream().map(g -> {
+            try {
+                return entityRetriever.toAtlasEntityHeader(g).getGuid();
+            } catch (AtlasBaseException e) {
+                fail("Failure in mapping vertex to AtlasEntityHeader");
+            }
+            return "";
+        }).collect(Collectors.toList());
+
+        Assert.assertTrue(guids.contains(entityGUID));
+
+    }
+
+    private void createEntityWithQualifiedName() throws AtlasBaseException {
+        AtlasEntity entityToDelete = new AtlasEntity(HDFS_PATH);
+        entityToDelete.setAttribute("name", "h1NameHDFS");
+        entityToDelete.setAttribute(AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, "h1qualifiedNameHDFS");
+        entityToDelete.setAttribute("path", "h1PathHDFS");
+
+        //create entity
+        final EntityMutationResponse response = entityStore.createOrUpdate(new AtlasEntityStream(new AtlasEntity.AtlasEntitiesWithExtInfo(entityToDelete)), false);
+        AtlasEntityHeader entityHeader = response.getCreatedEntities().get(0);
+        entityGUID = entityHeader.getGuid();
+
+    }
+
     @AfterClass
     public void teardown() throws Exception {
         AtlasGraphProvider.cleanup();
diff --git a/repository/src/test/java/org/apache/atlas/repository/store/graph/v2/AtlasEntityStoreV2Test.java b/repository/src/test/java/org/apache/atlas/repository/store/graph/v2/AtlasEntityStoreV2Test.java
index 1489b27..7b5cba5 100644
--- a/repository/src/test/java/org/apache/atlas/repository/store/graph/v2/AtlasEntityStoreV2Test.java
+++ b/repository/src/test/java/org/apache/atlas/repository/store/graph/v2/AtlasEntityStoreV2Test.java
@@ -1434,4 +1434,33 @@
             fail("The BusinessMetadata Attribute should have been assigned " +e);
         }
     }
+
+
+    @Test(dependsOnMethods = "deleteLabelsToEntity")
+    public void testCJKaddLabel() {
+
+        Set<String> labels = new HashSet();
+        labels.add("国家");
+        try {
+            AtlasEntity tblEntity = getEntityFromStore(tblEntityGuid);
+            int count = tblEntity.getLabels().size();
+            entityStore.setLabels(tblEntityGuid, labels);
+            tblEntity = getEntityFromStore(tblEntityGuid);
+            assertEquals(tblEntity.getLabels().size(), count + 1);
+        } catch (Exception e) {
+            LOG.error("An error occurred : " + e);
+        }
+    }
+
+    @Test()
+    public void addCJKCustomAttributes() throws Exception {
+
+        AtlasEntity tblEntity = getEntityFromStore(tblEntityGuid);
+        Map<String, String> customAttributes = new HashMap<>();
+        customAttributes.put("国家", "国家");
+        tblEntity.setCustomAttributes(customAttributes);
+        entityStore.createOrUpdate(new AtlasEntityStream(tblEntity), false);
+        tblEntity = getEntityFromStore(tblEntityGuid);
+        assertEquals(customAttributes, tblEntity.getCustomAttributes());
+    }
 }
\ No newline at end of file