cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jmcken...@apache.org
Subject [22/32] cassandra git commit: 2.2 commit for CASSANDRA-9160
Date Wed, 24 Jun 2015 16:15:15 GMT
http://git-wip-us.apache.org/repos/asf/cassandra/blob/01115f72/test/unit/org/apache/cassandra/cql3/UseStatementTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/UseStatementTest.java b/test/unit/org/apache/cassandra/cql3/UseStatementTest.java
deleted file mode 100644
index 66b4b42..0000000
--- a/test/unit/org/apache/cassandra/cql3/UseStatementTest.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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.cassandra.cql3;
-
-import org.junit.Test;
-
-public class UseStatementTest extends CQLTester
-{
-    @Test
-    public void testUseStatementWithBindVariable() throws Throwable
-    {
-        assertInvalidSyntaxMessage("Bind variables cannot be used for keyspace names", "USE
?");
-    }
-}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/01115f72/test/unit/org/apache/cassandra/cql3/UserTypesTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/UserTypesTest.java b/test/unit/org/apache/cassandra/cql3/UserTypesTest.java
deleted file mode 100644
index bfd3e9f..0000000
--- a/test/unit/org/apache/cassandra/cql3/UserTypesTest.java
+++ /dev/null
@@ -1,334 +0,0 @@
-/*
- * 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.cassandra.cql3;
-
-import org.junit.Test;
-
-public class UserTypesTest extends CQLTester
-{
-    @Test
-    public void testInvalidField() throws Throwable
-    {
-        String myType = createType("CREATE TYPE %s (f int)");
-        createTable("CREATE TABLE %s (k int PRIMARY KEY, v frozen<" + myType + ">)");
-
-        // 's' is not a field of myType
-        assertInvalid("INSERT INTO %s (k, v) VALUES (?, {s : ?})", 0, 1);
-    }
-
-    @Test
-    public void testCassandra8105() throws Throwable
-    {
-        String ut1 = createType("CREATE TYPE %s (a int, b int)");
-        String ut2 = createType("CREATE TYPE %s (j frozen<" + KEYSPACE + "." + ut1 + ">,
k int)");
-        createTable("CREATE TABLE %s (x int PRIMARY KEY, y set<frozen<" + KEYSPACE
+ "." + ut2 + ">>)");
-        execute("INSERT INTO %s (x, y) VALUES (1, { { k: 1 } })");
-
-        String ut3 = createType("CREATE TYPE %s (a int, b int)");
-        String ut4 = createType("CREATE TYPE %s (j frozen<" + KEYSPACE + "." + ut3 + ">,
k int)");
-        createTable("CREATE TABLE %s (x int PRIMARY KEY, y list<frozen<" + KEYSPACE
+ "." + ut4 + ">>)");
-        execute("INSERT INTO %s (x, y) VALUES (1, [ { k: 1 } ])");
-
-        String ut5 = createType("CREATE TYPE %s (a int, b int)");
-        String ut6 = createType("CREATE TYPE %s (i int, j frozen<" + KEYSPACE + "." +
ut5 + ">)");
-        createTable("CREATE TABLE %s (x int PRIMARY KEY, y set<frozen<" + KEYSPACE
+ "." + ut6 + ">>)");
-        execute("INSERT INTO %s (x, y) VALUES (1, { { i: 1 } })");
-    }
-
-    @Test
-    public void testFor7684() throws Throwable
-    {
-        String myType = createType("CREATE TYPE %s (x double)");
-        createTable("CREATE TABLE %s (k int, v frozen<" + myType + ">, b boolean static,
PRIMARY KEY (k, v))");
-
-        execute("INSERT INTO %s(k, v) VALUES (?, {x:?})", 1, -104.99251);
-        execute("UPDATE %s SET b = ? WHERE k = ?", true, 1);
-
-        assertRows(execute("SELECT v.x FROM %s WHERE k = ? AND v = {x:?}", 1, -104.99251),
-            row(-104.99251)
-        );
-
-        flush();
-
-        assertRows(execute("SELECT v.x FROM %s WHERE k = ? AND v = {x:?}", 1, -104.99251),
-            row(-104.99251)
-        );
-    }
-
-    @Test
-    public void testCreateInvalidTablesWithUDT() throws Throwable
-    {
-        String myType = createType("CREATE TYPE %s (f int)");
-
-        // Using a UDT without frozen shouldn't work
-        assertInvalidMessage("Non-frozen User-Defined types are not supported, please use
frozen<>",
-                             "CREATE TABLE " + KEYSPACE + ".wrong (k int PRIMARY KEY, v "
+ KEYSPACE + '.' + myType + ")");
-
-        assertInvalidMessage("Statement on keyspace " + KEYSPACE + " cannot refer to a user
type in keyspace otherkeyspace;" +
-                             " user types can only be used in the keyspace they are defined
in",
-                             "CREATE TABLE " + KEYSPACE + ".wrong (k int PRIMARY KEY, v frozen<otherKeyspace.myType>)");
-
-        assertInvalidMessage("Unknown type " + KEYSPACE + ".unknowntype",
-                             "CREATE TABLE " + KEYSPACE + ".wrong (k int PRIMARY KEY, v frozen<"
+ KEYSPACE + '.' + "unknownType>)");
-    }
-
-    @Test
-    public void testAlterUDT() throws Throwable
-    {
-        String myType = KEYSPACE + '.' + createType("CREATE TYPE %s (a int)");
-        createTable("CREATE TABLE %s (a int PRIMARY KEY, b frozen<" + myType + ">)");
-        execute("INSERT INTO %s (a, b) VALUES (1, {a: 1})");
-
-        assertRows(execute("SELECT b.a FROM %s"), row(1));
-
-        flush();
-
-        execute("ALTER TYPE " + myType + " ADD b int");
-        execute("INSERT INTO %s (a, b) VALUES (2, {a: 2, b :2})");
-
-        assertRows(execute("SELECT b.a, b.b FROM %s"),
-                   row(1, null),
-                   row(2, 2));
-
-        flush();
-
-        assertRows(execute("SELECT b.a, b.b FROM %s"),
-                   row(1, null),
-                   row(2, 2));
-    }
-
-    @Test
-    public void testUDTWithUnsetValues() throws Throwable
-    {
-        // set up
-        String myType = createType("CREATE TYPE %s (x int, y int)");
-        String myOtherType = createType("CREATE TYPE %s (a frozen<" + myType + ">)");
-        createTable("CREATE TABLE %s (k int PRIMARY KEY, v frozen<" + myType + ">,
z frozen<" + myOtherType + ">)");
-
-        assertInvalidMessage("Invalid unset value for field 'y' of user defined type " +
myType,
-                "INSERT INTO %s (k, v) VALUES (10, {x:?, y:?})", 1, unset());
-
-        assertInvalidMessage("Invalid unset value for field 'y' of user defined type " +
myType,
-                "INSERT INTO %s (k, v, z) VALUES (10, {x:?, y:?}, {a:{x: ?, y: ?}})", 1,
1, 1, unset());
-    }
-
-    @Test
-    public void testAlteringUserTypeNestedWithinMap() throws Throwable
-    {
-        // test frozen and non-frozen collections
-        String[] columnTypePrefixes = {"frozen<map<text, ", "map<text, frozen<"};
-        for (String columnTypePrefix : columnTypePrefixes)
-        {
-            String ut1 = createType("CREATE TYPE %s (a int)");
-            String columnType = columnTypePrefix + KEYSPACE + "." + ut1 + ">>";
-
-            createTable("CREATE TABLE %s (x int PRIMARY KEY, y " + columnType + ")");
-
-            execute("INSERT INTO %s (x, y) VALUES(1, {'firstValue':{a:1}})");
-            assertRows(execute("SELECT * FROM %s"), row(1, map("firstValue", userType(1))));
-            flush();
-
-            execute("ALTER TYPE " + KEYSPACE + "." + ut1 + " ADD b int");
-            execute("INSERT INTO %s (x, y) VALUES(2, {'secondValue':{a:2, b:2}})");
-            execute("INSERT INTO %s (x, y) VALUES(3, {'thirdValue':{a:3}})");
-            execute("INSERT INTO %s (x, y) VALUES(4, {'fourthValue':{b:4}})");
-
-            assertRows(execute("SELECT * FROM %s"),
-                    row(1, map("firstValue", userType(1))),
-                    row(2, map("secondValue", userType(2, 2))),
-                    row(3, map("thirdValue", userType(3, null))),
-                    row(4, map("fourthValue", userType(null, 4))));
-
-            flush();
-
-            assertRows(execute("SELECT * FROM %s"),
-                    row(1, map("firstValue", userType(1))),
-                    row(2, map("secondValue", userType(2, 2))),
-                    row(3, map("thirdValue", userType(3, null))),
-                    row(4, map("fourthValue", userType(null, 4))));
-        }
-    }
-
-    @Test
-    public void testAlteringUserTypeNestedWithinSet() throws Throwable
-    {
-        // test frozen and non-frozen collections
-        String[] columnTypePrefixes = {"frozen<set<", "set<frozen<"};
-        for (String columnTypePrefix : columnTypePrefixes)
-        {
-            String ut1 = createType("CREATE TYPE %s (a int)");
-            String columnType = columnTypePrefix + KEYSPACE + "." + ut1 + ">>";
-
-            createTable("CREATE TABLE %s (x int PRIMARY KEY, y " + columnType + ")");
-
-            execute("INSERT INTO %s (x, y) VALUES(1, {1} )");
-            assertRows(execute("SELECT * FROM %s"), row(1, set(userType(1))));
-            flush();
-
-            execute("ALTER TYPE " + KEYSPACE + "." + ut1 + " ADD b int");
-            execute("INSERT INTO %s (x, y) VALUES(2, {{a:2, b:2}})");
-            execute("INSERT INTO %s (x, y) VALUES(3, {{a:3}})");
-            execute("INSERT INTO %s (x, y) VALUES(4, {{b:4}})");
-
-            assertRows(execute("SELECT * FROM %s"),
-                    row(1, set(userType(1))),
-                    row(2, set(userType(2, 2))),
-                    row(3, set(userType(3, null))),
-                    row(4, set(userType(null, 4))));
-
-            flush();
-
-            assertRows(execute("SELECT * FROM %s"),
-                    row(1, set(userType(1))),
-                    row(2, set(userType(2, 2))),
-                    row(3, set(userType(3, null))),
-                    row(4, set(userType(null, 4))));
-        }
-    }
-
-    @Test
-    public void testAlteringUserTypeNestedWithinList() throws Throwable
-    {
-        // test frozen and non-frozen collections
-        String[] columnTypePrefixes = {"frozen<list<", "list<frozen<"};
-        for (String columnTypePrefix : columnTypePrefixes)
-        {
-            String ut1 = createType("CREATE TYPE %s (a int)");
-            String columnType = columnTypePrefix + KEYSPACE + "." + ut1 + ">>";
-
-            createTable("CREATE TABLE %s (x int PRIMARY KEY, y " + columnType + ")");
-
-            execute("INSERT INTO %s (x, y) VALUES(1, [1] )");
-            assertRows(execute("SELECT * FROM %s"), row(1, list(userType(1))));
-            flush();
-
-            execute("ALTER TYPE " + KEYSPACE + "." + ut1 + " ADD b int");
-            execute("INSERT INTO %s (x, y) VALUES(2, [{a:2, b:2}])");
-            execute("INSERT INTO %s (x, y) VALUES(3, [{a:3}])");
-            execute("INSERT INTO %s (x, y) VALUES(4, [{b:4}])");
-
-            assertRows(execute("SELECT * FROM %s"),
-                    row(1, list(userType(1))),
-                    row(2, list(userType(2, 2))),
-                    row(3, list(userType(3, null))),
-                    row(4, list(userType(null, 4))));
-
-            flush();
-
-            assertRows(execute("SELECT * FROM %s"),
-                    row(1, list(userType(1))),
-                    row(2, list(userType(2, 2))),
-                    row(3, list(userType(3, null))),
-                    row(4, list(userType(null, 4))));
-        }
-    }
-
-    @Test
-    public void testAlteringUserTypeNestedWithinTuple() throws Throwable
-    {
-        String type = createType("CREATE TYPE %s (a int, b int)");
-
-        createTable("CREATE TABLE %s (a int PRIMARY KEY, b frozen<tuple<int, " + KEYSPACE
+ "." + type + ">>)");
-
-        execute("INSERT INTO %s (a, b) VALUES(1, (1, {a:1, b:1}))");
-        assertRows(execute("SELECT * FROM %s"), row(1, tuple(1, userType(1, 1))));
-        flush();
-
-        execute("ALTER TYPE " + KEYSPACE + "." + type + " ADD c int");
-        execute("INSERT INTO %s (a, b) VALUES(2, (2, {a: 2, b: 2, c: 2}))");
-        execute("INSERT INTO %s (a, b) VALUES(3, (3, {a: 3, b: 3}))");
-        execute("INSERT INTO %s (a, b) VALUES(4, (4, {b:4}))");
-
-        assertRows(execute("SELECT * FROM %s"),
-                   row(1, tuple(1, userType(1, 1))),
-                   row(2, tuple(2, userType(2, 2, 2))),
-                   row(3, tuple(3, userType(3, 3, null))),
-                   row(4, tuple(4, userType(null, 4, null))));
-
-        flush();
-
-        assertRows(execute("SELECT * FROM %s"),
-                   row(1, tuple(1, userType(1, 1))),
-                   row(2, tuple(2, userType(2, 2, 2))),
-                   row(3, tuple(3, userType(3, 3, null))),
-                   row(4, tuple(4, userType(null, 4, null))));
-    }
-
-    @Test
-    public void testAlteringUserTypeNestedWithinNestedTuple() throws Throwable
-    {
-        String type = createType("CREATE TYPE %s (a int, b int)");
-
-        createTable("CREATE TABLE %s (a int PRIMARY KEY, b frozen<tuple<int, tuple<int,
" + KEYSPACE + "." + type + ">>>)");
-
-        execute("INSERT INTO %s (a, b) VALUES(1, (1, (1, {a:1, b:1})))");
-        assertRows(execute("SELECT * FROM %s"), row(1, tuple(1, tuple(1, userType(1, 1)))));
-        flush();
-
-        execute("ALTER TYPE " + KEYSPACE + "." + type + " ADD c int");
-        execute("INSERT INTO %s (a, b) VALUES(2, (2, (1, {a: 2, b: 2, c: 2})))");
-        execute("INSERT INTO %s (a, b) VALUES(3, (3, (1, {a: 3, b: 3})))");
-        execute("INSERT INTO %s (a, b) VALUES(4, (4, (1, {b:4})))");
-
-        assertRows(execute("SELECT * FROM %s"),
-                   row(1, tuple(1, tuple(1, userType(1, 1)))),
-                   row(2, tuple(2, tuple(1, userType(2, 2, 2)))),
-                   row(3, tuple(3, tuple(1, userType(3, 3, null)))),
-                   row(4, tuple(4, tuple(1, userType(null, 4, null)))));
-
-        flush();
-
-        assertRows(execute("SELECT * FROM %s"),
-                   row(1, tuple(1, tuple(1, userType(1, 1)))),
-                   row(2, tuple(2, tuple(1, userType(2, 2, 2)))),
-                   row(3, tuple(3, tuple(1, userType(3, 3, null)))),
-                   row(4, tuple(4, tuple(1, userType(null, 4, null)))));
-    }
-
-    @Test
-    public void testAlteringUserTypeNestedWithinUserType() throws Throwable
-    {
-        String type = createType("CREATE TYPE %s (a int, b int)");
-        String otherType = createType("CREATE TYPE %s (x frozen<" + KEYSPACE + "." + type
+ ">)");
-
-        createTable("CREATE TABLE %s (a int PRIMARY KEY, b frozen<" + KEYSPACE + "." +
otherType + ">)");
-
-        execute("INSERT INTO %s (a, b) VALUES(1, {x: {a:1, b:1}})");
-        assertRows(execute("SELECT b.x.a, b.x.b FROM %s"), row(1, 1));
-        flush();
-
-        execute("ALTER TYPE " + KEYSPACE + "." + type + " ADD c int");
-        execute("INSERT INTO %s (a, b) VALUES(2, {x: {a: 2, b: 2, c: 2}})");
-        execute("INSERT INTO %s (a, b) VALUES(3, {x: {a: 3, b: 3}})");
-        execute("INSERT INTO %s (a, b) VALUES(4, {x: {b:4}})");
-
-        assertRows(execute("SELECT b.x.a, b.x.b, b.x.c FROM %s"),
-                   row(1, 1, null),
-                   row(2, 2, 2),
-                   row(3, 3, null),
-                   row(null, 4, null));
-
-        flush();
-
-        assertRows(execute("SELECT b.x.a, b.x.b, b.x.c FROM %s"),
-                   row(1, 1, null),
-                   row(2, 2, 2),
-                   row(3, 3, null),
-                   row(null, 4, null));
-    }
-}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/01115f72/test/unit/org/apache/cassandra/cql3/selection/SelectionColumnMappingTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/selection/SelectionColumnMappingTest.java
b/test/unit/org/apache/cassandra/cql3/selection/SelectionColumnMappingTest.java
index 5bacf0d..2f1d361 100644
--- a/test/unit/org/apache/cassandra/cql3/selection/SelectionColumnMappingTest.java
+++ b/test/unit/org/apache/cassandra/cql3/selection/SelectionColumnMappingTest.java
@@ -3,13 +3,16 @@ package org.apache.cassandra.cql3.selection;
 import java.util.Collections;
 
 import com.google.common.collect.ImmutableList;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import org.apache.cassandra.config.ColumnDefinition;
+import org.apache.cassandra.config.DatabaseDescriptor;
 import org.apache.cassandra.config.Schema;
 import org.apache.cassandra.cql3.*;
 import org.apache.cassandra.cql3.statements.SelectStatement;
 import org.apache.cassandra.db.marshal.*;
+import org.apache.cassandra.dht.ByteOrderedPartitioner;
 import org.apache.cassandra.exceptions.RequestValidationException;
 import org.apache.cassandra.service.ClientState;
 import org.apache.cassandra.utils.ByteBufferUtil;
@@ -25,6 +28,12 @@ public class SelectionColumnMappingTest extends CQLTester
     UserType userType;
     String functionName;
 
+    @BeforeClass
+    public static void setUpClass()
+    {
+        DatabaseDescriptor.setPartitioner(ByteOrderedPartitioner.instance);
+    }
+
     @Test
     public void testSelectionColumnMapping() throws Throwable
     {

http://git-wip-us.apache.org/repos/asf/cassandra/blob/01115f72/test/unit/org/apache/cassandra/cql3/validation/entities/CollectionsTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/validation/entities/CollectionsTest.java
b/test/unit/org/apache/cassandra/cql3/validation/entities/CollectionsTest.java
new file mode 100644
index 0000000..2e72c39
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/validation/entities/CollectionsTest.java
@@ -0,0 +1,588 @@
+/*
+ * 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.cassandra.cql3.validation.entities;
+
+import java.util.UUID;
+
+import org.junit.Test;
+
+import org.apache.cassandra.cql3.CQLTester;
+
+public class CollectionsTest extends CQLTester
+{
+    @Test
+    public void testMapBulkRemoval() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, m map<text, text>)");
+
+        execute("INSERT INTO %s(k, m) VALUES (?, ?)", 0, map("k1", "v1", "k2", "v2", "k3",
"v3"));
+
+        assertRows(execute("SELECT * FROM %s"),
+            row(0, map("k1", "v1", "k2", "v2", "k3", "v3"))
+        );
+
+        execute("UPDATE %s SET m = m - ? WHERE k = ?", set("k2"), 0);
+
+        assertRows(execute("SELECT * FROM %s"),
+            row(0, map("k1", "v1", "k3", "v3"))
+        );
+
+        execute("UPDATE %s SET m = m + ?, m = m - ? WHERE k = ?", map("k4", "v4"), set("k3"),
0);
+
+        assertRows(execute("SELECT * FROM %s"),
+            row(0, map("k1", "v1", "k4", "v4"))
+        );
+    }
+
+    @Test
+    public void testInvalidCollectionsMix() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, l list<text>, s set<text>,
m map<text, text>)");
+
+        // Note: we force the non-prepared form for some of those tests because a list and
a set
+        // have the same serialized format in practice and CQLTester don't validate that
the type
+        // of what's passed as a value in the prepared case, so the queries would work (which
is ok,
+        // CQLTester is just a "dumb" client).
+
+        assertInvalid("UPDATE %s SET l = l + { 'a', 'b' } WHERE k = 0");
+        assertInvalid("UPDATE %s SET l = l - { 'a', 'b' } WHERE k = 0");
+        assertInvalid("UPDATE %s SET l = l + ? WHERE k = 0", map("a", "b", "c", "d"));
+        assertInvalid("UPDATE %s SET l = l - ? WHERE k = 0", map("a", "b", "c", "d"));
+
+        assertInvalid("UPDATE %s SET s = s + [ 'a', 'b' ] WHERE k = 0");
+        assertInvalid("UPDATE %s SET s = s - [ 'a', 'b' ] WHERE k = 0");
+        assertInvalid("UPDATE %s SET s = s + ? WHERE k = 0", map("a", "b", "c", "d"));
+        assertInvalid("UPDATE %s SET s = s - ? WHERE k = 0", map("a", "b", "c", "d"));
+
+        assertInvalid("UPDATE %s SET m = m + ? WHERE k = 0", list("a", "b"));
+        assertInvalid("UPDATE %s SET m = m - [ 'a', 'b' ] WHERE k = 0");
+        assertInvalid("UPDATE %s SET m = m + ? WHERE k = 0", set("a", "b"));
+        assertInvalid("UPDATE %s SET m = m - ? WHERE k = 0", map("a", "b", "c", "d"));
+    }
+
+    @Test
+    public void testSets() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, s set<text>)");
+
+        execute("INSERT INTO %s(k, s) VALUES (0, ?)", set("v1", "v2", "v3", "v4"));
+
+        assertRows(execute("SELECT s FROM %s WHERE k = 0"),
+            row(set("v1", "v2", "v3", "v4"))
+        );
+
+        execute("DELETE s[?] FROM %s WHERE k = 0", "v1");
+
+        assertRows(execute("SELECT s FROM %s WHERE k = 0"),
+                   row(set("v2", "v3", "v4"))
+        );
+
+        // Full overwrite
+        execute("UPDATE %s SET s = ? WHERE k = 0", set("v6", "v5"));
+
+        assertRows(execute("SELECT s FROM %s WHERE k = 0"),
+                   row(set("v5", "v6"))
+        );
+
+        execute("UPDATE %s SET s = s + ? WHERE k = 0", set("v7"));
+
+        assertRows(execute("SELECT s FROM %s WHERE k = 0"),
+                   row(set("v5", "v6", "v7"))
+        );
+
+        execute("UPDATE %s SET s = s - ? WHERE k = 0", set("v6", "v5"));
+
+        assertRows(execute("SELECT s FROM %s WHERE k = 0"),
+                   row(set("v7"))
+        );
+
+        execute("DELETE s[?] FROM %s WHERE k = 0", set("v7"));
+
+        // Deleting an element that does not exist will succeed
+        execute("DELETE s[?] FROM %s WHERE k = 0", set("v7"));
+
+        execute("DELETE s FROM %s WHERE k = 0");
+
+        assertRows(execute("SELECT s FROM %s WHERE k = 0"),
+                   row((Object) null)
+        );
+    }
+
+    @Test
+    public void testMaps() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, m map<text, int>)");
+
+        execute("INSERT INTO %s(k, m) VALUES (0, ?)", map("v1", 1, "v2", 2));
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+            row(map("v1", 1, "v2", 2))
+        );
+
+        execute("UPDATE %s SET m[?] = ?, m[?] = ? WHERE k = 0", "v3", 3, "v4", 4);
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+            row(map("v1", 1, "v2", 2, "v3", 3, "v4", 4))
+        );
+
+        execute("DELETE m[?] FROM %s WHERE k = 0", "v1");
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+            row(map("v2", 2, "v3", 3, "v4", 4))
+        );
+
+        // Full overwrite
+        execute("UPDATE %s SET m = ? WHERE k = 0", map("v6", 6, "v5", 5));
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+                   row(map("v5", 5, "v6", 6))
+        );
+
+        execute("UPDATE %s SET m = m + ? WHERE k = 0", map("v7", 7));
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+                   row(map("v5", 5, "v6", 6, "v7", 7))
+        );
+
+        execute("DELETE m[?] FROM %s WHERE k = 0", "v7");
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+                   row(map("v5", 5, "v6", 6))
+        );
+
+        execute("DELETE m[?] FROM %s WHERE k = 0", "v6");
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+                   row(map("v5", 5))
+        );
+
+        execute("DELETE m[?] FROM %s WHERE k = 0", "v5");
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+                   row((Object) null)
+        );
+
+        // Deleting a non-existing key should succeed
+        execute("DELETE m[?] FROM %s WHERE k = 0", "v5");
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+                   row((Object) null)
+        );
+
+        // The empty map is parsed as an empty set (because we don't have enough info at
parsing
+        // time when we see a {}) and special cased later. This test checks this work properly
+        execute("UPDATE %s SET m = {} WHERE k = 0");
+
+        assertRows(execute("SELECT m FROM %s WHERE k = 0"),
+            row((Object)null)
+        );
+    }
+
+    @Test
+    public void testLists() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, l list<text>)");
+
+        execute("INSERT INTO %s(k, l) VALUES (0, ?)", list("v1", "v2", "v3"));
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list("v1", "v2", "v3")));
+
+        execute("DELETE l[?] FROM %s WHERE k = 0", 1);
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list("v1", "v3")));
+
+        execute("UPDATE %s SET l[?] = ? WHERE k = 0", 1, "v4");
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list("v1", "v4")));
+
+        // Full overwrite
+        execute("UPDATE %s SET l = ? WHERE k = 0", list("v6", "v5"));
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list("v6", "v5")));
+
+        execute("UPDATE %s SET l = l + ? WHERE k = 0", list("v7", "v8"));
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list("v6", "v5", "v7", "v8")));
+
+        execute("UPDATE %s SET l = ? + l WHERE k = 0", list("v9"));
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list("v9", "v6", "v5", "v7",
"v8")));
+
+        execute("UPDATE %s SET l = l - ? WHERE k = 0", list("v5", "v8"));
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list("v9", "v6", "v7")));
+
+        execute("DELETE l FROM %s WHERE k = 0");
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row((Object) null));
+
+        assertInvalidMessage("Attempted to delete an element from a list which is null",
+                             "DELETE l[0] FROM %s WHERE k=0 ");
+
+        assertInvalidMessage("Attempted to set an element on a list which is null",
+                             "UPDATE %s SET l[0] = ? WHERE k=0", list("v10"));
+
+        execute("UPDATE %s SET l = l - ? WHERE k=0 ", list("v11"));
+
+        assertRows(execute("SELECT l FROM %s WHERE k = 0"), row((Object) null));
+    }
+
+    @Test
+    public void testMapWithUnsetValues() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, m map<text,text>)");
+        // set up
+        Object m = map("k", "v");
+        execute("INSERT INTO %s (k, m) VALUES (10, ?)", m);
+        assertRows(execute("SELECT m FROM %s WHERE k = 10"),
+                   row(m)
+        );
+
+        // test putting an unset map, should not delete the contents
+        execute("INSERT INTO %s (k, m) VALUES (10, ?)", unset());
+        assertRows(execute("SELECT m FROM %s WHERE k = 10"),
+                   row(m)
+        );
+        // test unset variables in a map update operaiotn, should not delete the contents
+        execute("UPDATE %s SET m['k'] = ? WHERE k = 10", unset());
+        assertRows(execute("SELECT m FROM %s WHERE k = 10"),
+                   row(m)
+        );
+        assertInvalidMessage("Invalid unset map key", "UPDATE %s SET m[?] = 'foo' WHERE k
= 10", unset());
+
+        // test unset value for map key
+        assertInvalidMessage("Invalid unset map key", "DELETE m[?] FROM %s WHERE k = 10",
unset());
+    }
+
+    @Test
+    public void testListWithUnsetValues() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, l list<text>)");
+        // set up
+        Object l = list("foo", "foo");
+        execute("INSERT INTO %s (k, l) VALUES (10, ?)", l);
+        assertRows(execute("SELECT l FROM %s WHERE k = 10"),
+                   row(l)
+        );
+
+        // replace list with unset value
+        execute("INSERT INTO %s (k, l) VALUES (10, ?)", unset());
+        assertRows(execute("SELECT l FROM %s WHERE k = 10"),
+                   row(l)
+        );
+
+        // add to position
+        execute("UPDATE %s SET l[1] = ? WHERE k = 10", unset());
+        assertRows(execute("SELECT l FROM %s WHERE k = 10"),
+                   row(l)
+        );
+
+        // set in index
+        assertInvalidMessage("Invalid unset value for list index", "UPDATE %s SET l[?] =
'foo' WHERE k = 10", unset());
+
+        // remove element by index
+        execute("DELETE l[?] FROM %s WHERE k = 10", unset());
+        assertRows(execute("SELECT l FROM %s WHERE k = 10"),
+                   row(l)
+        );
+
+        // remove all occurrences of element
+        execute("UPDATE %s SET l = l - ? WHERE k = 10", unset());
+        assertRows(execute("SELECT l FROM %s WHERE k = 10"),
+                   row(l)
+        );
+
+        // select with in clause
+        assertInvalidMessage("Invalid unset value for column k", "SELECT * FROM %s WHERE
k IN ?", unset());
+        assertInvalidMessage("Invalid unset value for column k", "SELECT * FROM %s WHERE
k IN (?)", unset());
+    }
+
+    @Test
+    public void testSetWithUnsetValues() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, s set<text>)");
+
+        Object s = set("bar", "baz", "foo");
+        execute("INSERT INTO %s (k, s) VALUES (10, ?)", s);
+        assertRows(execute("SELECT s FROM %s WHERE k = 10"),
+                   row(s)
+        );
+
+        // replace set with unset value
+        execute("INSERT INTO %s (k, s) VALUES (10, ?)", unset());
+        assertRows(execute("SELECT s FROM %s WHERE k = 10"),
+                   row(s)
+        );
+
+        // add to set
+        execute("UPDATE %s SET s = s + ? WHERE k = 10", unset());
+        assertRows(execute("SELECT s FROM %s WHERE k = 10"),
+                   row(s)
+        );
+
+        // remove all occurrences of element
+        execute("UPDATE %s SET s = s - ? WHERE k = 10", unset());
+        assertRows(execute("SELECT s FROM %s WHERE k = 10"),
+                   row(s)
+        );
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.set_test()
+     */
+    @Test
+    public void testSet() throws Throwable
+    {
+        createTable("CREATE TABLE %s ( fn text, ln text, tags set<text>, PRIMARY KEY
(fn, ln) )");
+
+        execute("UPDATE %s SET tags = tags + { 'foo' } WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET tags = tags + { 'bar' } WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET tags = tags + { 'foo' } WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET tags = tags + { 'foobar' } WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET tags = tags - { 'bar' } WHERE fn='Tom' AND ln='Bombadil'");
+
+        assertRows(execute("SELECT tags FROM %s"),
+                   row(set("foo", "foobar")));
+
+        execute("UPDATE %s SET tags = { 'a', 'c', 'b' } WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(set("a", "b", "c")));
+
+        execute("UPDATE %s SET tags = { 'm', 'n' } WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(set("m", "n")));
+
+        execute("DELETE tags['m'] FROM %s WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(set("n")));
+
+        execute("DELETE tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'");
+        assertEmpty(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.map_test()
+     */
+    @Test
+    public void testMap() throws Throwable
+    {
+        createTable("CREATE TABLE %s (fn text, ln text, m map<text, int>, PRIMARY KEY
(fn, ln))");
+
+        execute("UPDATE %s SET m['foo'] = 3 WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET m['bar'] = 4 WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET m['woot'] = 5 WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET m['bar'] = 6 WHERE fn='Tom' AND ln='Bombadil'");
+        execute("DELETE m['foo'] FROM %s WHERE fn='Tom' AND ln='Bombadil'");
+
+        assertRows(execute("SELECT m FROM %s"),
+                   row(map("bar", 6, "woot", 5)));
+
+        execute("UPDATE %s SET m = { 'a' : 4 , 'c' : 3, 'b' : 2 } WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT m FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(map("a", 4, "b", 2, "c", 3)));
+
+        execute("UPDATE %s SET m =  { 'm' : 4 , 'n' : 1, 'o' : 2 } WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT m FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(map("m", 4, "n", 1, "o", 2)));
+
+        execute("UPDATE %s SET m = {} WHERE fn='Bilbo' AND ln='Baggins'");
+        assertEmpty(execute("SELECT m FROM %s WHERE fn='Bilbo' AND ln='Baggins'"));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.list_test()
+     */
+    @Test
+    public void testList() throws Throwable
+    {
+        createTable("CREATE TABLE %s (fn text, ln text, tags list<text>, PRIMARY KEY
(fn, ln))");
+
+        execute("UPDATE %s SET tags = tags + [ 'foo' ] WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET tags = tags + [ 'bar' ] WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET tags = tags + [ 'foo' ] WHERE fn='Tom' AND ln='Bombadil'");
+        execute("UPDATE %s SET tags = tags + [ 'foobar' ] WHERE fn='Tom' AND ln='Bombadil'");
+
+        assertRows(execute("SELECT tags FROM %s"),
+                   row(list("foo", "bar", "foo", "foobar")));
+
+        execute("UPDATE %s SET tags = [ 'a', 'c', 'b', 'c' ] WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(list("a", "c", "b", "c")));
+
+        execute("UPDATE %s SET tags = [ 'm', 'n' ] + tags WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(list("m", "n", "a", "c", "b", "c")));
+
+        execute("UPDATE %s SET tags[2] = 'foo', tags[4] = 'bar' WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(list("m", "n", "foo", "c", "bar", "c")));
+
+        execute("DELETE tags[2] FROM %s WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(list("m", "n", "c", "bar", "c")));
+
+        execute("UPDATE %s SET tags = tags - [ 'bar' ] WHERE fn='Bilbo' AND ln='Baggins'");
+        assertRows(execute("SELECT tags FROM %s WHERE fn='Bilbo' AND ln='Baggins'"),
+                   row(list("m", "n", "c", "c")));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.multi_collection_test()
+     */
+    @Test
+    public void testMultiCollections() throws Throwable
+    {
+        UUID id = UUID.fromString("b017f48f-ae67-11e1-9096-005056c00008");
+
+        createTable("CREATE TABLE %s (k uuid PRIMARY KEY, L list<int>, M map<text,
int>, S set<int> )");
+
+        execute("UPDATE %s SET L = [1, 3, 5] WHERE k = ?", id);
+        execute("UPDATE %s SET L = L + [7, 11, 13] WHERE k = ?;", id);
+        execute("UPDATE %s SET S = {1, 3, 5} WHERE k = ?", id);
+        execute("UPDATE %s SET S = S + {7, 11, 13} WHERE k = ?", id);
+        execute("UPDATE %s SET M = {'foo': 1, 'bar' : 3} WHERE k = ?", id);
+        execute("UPDATE %s SET M = M + {'foobar' : 4} WHERE k = ?", id);
+
+        assertRows(execute("SELECT L, M, S FROM %s WHERE k = ?", id),
+                   row(list(1, 3, 5, 7, 11, 13),
+                       map("bar", 3, "foo", 1, "foobar", 4),
+                       set(1, 3, 5, 7, 11, 13)));
+    }
+
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.collection_and_regular_test()
+     */
+    @Test
+    public void testCollectionAndRegularColumns() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, l list<int>, c int)");
+
+        execute("INSERT INTO %s (k, l, c) VALUES(3, [0, 1, 2], 4)");
+        execute("UPDATE %s SET l[0] = 1, c = 42 WHERE k = 3");
+        assertRows(execute("SELECT l, c FROM %s WHERE k = 3"),
+                   row(list(1, 1, 2), 42));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.multi_list_set_test()
+     */
+    @Test
+    public void testMultipleLists() throws Throwable
+    {
+        createTable(" CREATE TABLE %s (k int PRIMARY KEY, l1 list<int>, l2 list<int>)");
+
+        execute("INSERT INTO %s (k, l1, l2) VALUES (0, [1, 2, 3], [4, 5, 6])");
+        execute("UPDATE %s SET l2[1] = 42, l1[1] = 24  WHERE k = 0");
+
+        assertRows(execute("SELECT l1, l2 FROM %s WHERE k = 0"),
+                   row(list(1, 24, 3), list(4, 42, 6)));
+    }
+
+    /**
+     * Test you can add columns in a table with collections (#4982 bug),
+     * migrated from cql_tests.py:TestCQL.alter_with_collections_test()
+     */
+    @Test
+    public void testAlterCollections() throws Throwable
+    {
+        createTable("CREATE TABLE %s (key int PRIMARY KEY, aset set<text>)");
+        execute("ALTER TABLE %s ADD c text");
+        execute("ALTER TABLE %s ADD alist list<text>");
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.collection_compact_test()
+     */
+    @Test
+    public void testCompactCollections() throws Throwable
+    {
+        String tableName = KEYSPACE + "." + createTableName();
+        assertInvalid(String.format("CREATE TABLE %s (user ascii PRIMARY KEY, mails list
< text >) WITH COMPACT STORAGE;", tableName));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.collection_function_test()
+     */
+    @Test
+    public void testFunctionsOnCollections() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, l set<int>)");
+
+        assertInvalid("SELECT ttl(l) FROM %s WHERE k = 0");
+        assertInvalid("SELECT writetime(l) FROM %s WHERE k = 0");
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.bug_5376()
+     */
+    @Test
+    public void testInClauseWithCollections() throws Throwable
+    {
+        createTable("CREATE TABLE %s (key text, c bigint, v text, x set < text >, PRIMARY
KEY(key, c) )");
+
+        assertInvalid("select * from %s where key = 'foo' and c in (1,3,4)");
+    }
+
+    /**
+     * Test for bug #5795,
+     * migrated from cql_tests.py:TestCQL.nonpure_function_collection_test()
+     */
+    @Test
+    public void testNonPureFunctionCollection() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, v list<timeuuid>)");
+
+        // we just want to make sure this doesn't throw
+        execute("INSERT INTO %s (k, v) VALUES (0, [now()])");
+    }
+
+    /**
+     * Test for 5805 bug,
+     * migrated from cql_tests.py:TestCQL.collection_flush_test()
+     */
+    @Test
+    public void testCollectionFlush() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, s set<int>)");
+
+        execute("INSERT INTO %s (k, s) VALUES (1, {1})");
+        flush();
+
+        execute("INSERT INTO %s (k, s) VALUES (1, {2})");
+        flush();
+
+        assertRows(execute("SELECT * FROM %s"),
+                   row(1, set(2)));
+    }
+
+    /**
+     * Test for 6276,
+     * migrated from cql_tests.py:TestCQL.drop_and_readd_collection_test()
+     */
+    @Test
+    public void testDropAndReaddCollection() throws Throwable
+    {
+        createTable("create table %s (k int primary key, v set<text>, x int)");
+        execute("insert into %s (k, v) VALUES (0, {'fffffffff'})");
+        flush();
+        execute("alter table %s drop v");
+        assertInvalid("alter table %s add v set<int>");
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/01115f72/test/unit/org/apache/cassandra/cql3/validation/entities/CountersTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/validation/entities/CountersTest.java b/test/unit/org/apache/cassandra/cql3/validation/entities/CountersTest.java
new file mode 100644
index 0000000..e5ff251
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/validation/entities/CountersTest.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.cassandra.cql3.validation.entities;
+
+import org.junit.Test;
+
+import org.apache.cassandra.cql3.CQLTester;
+import org.apache.cassandra.exceptions.ConfigurationException;
+import org.apache.cassandra.exceptions.InvalidRequestException;
+
+public class CountersTest extends CQLTester
+{
+    /**
+     * Check for a table with counters,
+     * migrated from cql_tests.py:TestCQL.counters_test()
+     */
+    @Test
+    public void testCounters() throws Throwable
+    {
+        createTable("CREATE TABLE %s (userid int, url text, total counter, PRIMARY KEY (userid,
url)) WITH COMPACT STORAGE");
+
+        execute("UPDATE %s SET total = total + 1 WHERE userid = 1 AND url = 'http://foo.com'");
+        assertRows(execute("SELECT total FROM %s WHERE userid = 1 AND url = 'http://foo.com'"),
+                   row(1L));
+
+        execute("UPDATE %s SET total = total - 4 WHERE userid = 1 AND url = 'http://foo.com'");
+        assertRows(execute("SELECT total FROM %s WHERE userid = 1 AND url = 'http://foo.com'"),
+                   row(-3L));
+
+        execute("UPDATE %s SET total = total+1 WHERE userid = 1 AND url = 'http://foo.com'");
+        assertRows(execute("SELECT total FROM %s WHERE userid = 1 AND url = 'http://foo.com'"),
+                   row(-2L));
+
+        execute("UPDATE %s SET total = total -2 WHERE userid = 1 AND url = 'http://foo.com'");
+        assertRows(execute("SELECT total FROM %s WHERE userid = 1 AND url = 'http://foo.com'"),
+                   row(-4L));
+    }
+
+    /**
+     * Test for the validation bug of #4706,
+     * migrated from cql_tests.py:TestCQL.validate_counter_regular_test()
+     */
+    @Test
+    public void testRegularCounters() throws Throwable
+    {
+        assertInvalidThrowMessage("Cannot add a non counter column",
+                                  ConfigurationException.class,
+                                  String.format("CREATE TABLE %s.%s (id bigint PRIMARY KEY,
count counter, things set<text>)", KEYSPACE, createTableName()));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.collection_counter_test()
+     */
+    @Test
+    public void testCountersOnCollections() throws Throwable
+    {
+        String tableName = KEYSPACE + "." + createTableName();
+        assertInvalidThrow(InvalidRequestException.class,
+                           String.format("CREATE TABLE %s (k int PRIMARY KEY, l list<counter>)",
tableName));
+
+        tableName = KEYSPACE + "." + createTableName();
+        assertInvalidThrow(InvalidRequestException.class,
+                           String.format("CREATE TABLE %s (k int PRIMARY KEY, s set<counter>)",
tableName));
+
+        tableName = KEYSPACE + "." + createTableName();
+        assertInvalidThrow(InvalidRequestException.class,
+                           String.format("CREATE TABLE %s (k int PRIMARY KEY, m map<text,
counter>)", tableName));
+    }
+
+    @Test
+    public void testCounterUpdatesWithUnset() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, c counter)");
+
+        // set up
+        execute("UPDATE %s SET c = c + 1 WHERE k = 10");
+        assertRows(execute("SELECT c FROM %s WHERE k = 10"),
+                   row(1L)
+        );
+        // increment
+        execute("UPDATE %s SET c = c + ? WHERE k = 10", 1L);
+        assertRows(execute("SELECT c FROM %s WHERE k = 10"),
+                   row(2L)
+        );
+        execute("UPDATE %s SET c = c + ? WHERE k = 10", unset());
+        assertRows(execute("SELECT c FROM %s WHERE k = 10"),
+                   row(2L) // no change to the counter value
+        );
+        // decrement
+        execute("UPDATE %s SET c = c - ? WHERE k = 10", 1L);
+        assertRows(execute("SELECT c FROM %s WHERE k = 10"),
+                   row(1L)
+        );
+        execute("UPDATE %s SET c = c - ? WHERE k = 10", unset());
+        assertRows(execute("SELECT c FROM %s WHERE k = 10"),
+                   row(1L) // no change to the counter value
+        );
+    }
+}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/01115f72/test/unit/org/apache/cassandra/cql3/validation/entities/DateTypeTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/validation/entities/DateTypeTest.java b/test/unit/org/apache/cassandra/cql3/validation/entities/DateTypeTest.java
new file mode 100644
index 0000000..7fa5e67
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/validation/entities/DateTypeTest.java
@@ -0,0 +1,39 @@
+/*
+ * 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.cassandra.cql3.validation.entities;
+
+import org.junit.Test;
+
+import org.apache.cassandra.cql3.CQLTester;
+
+public class DateTypeTest extends CQLTester
+{
+    /**
+     * Check dates are correctly recognized and validated,
+     * migrated from cql_tests.py:TestCQL.date_test()
+     */
+    @Test
+    public void testDate() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, t timestamp)");
+
+        execute("INSERT INTO %s (k, t) VALUES (0, '2011-02-03')");
+        assertInvalid("INSERT INTO %s (k, t) VALUES (0, '2011-42-42')");
+    }
+}


Mime
View raw message