Code Duplication - evseevnn/php-cassandra-binary - Measure and Improve Code Quality continuously with Scrutinizer



use evseevnn\Cassandra;

class QueryAsciiTest extends Setup\QueryTestCase
{

		public function testAsciiColumn()
		{
				self::$connection->query('CREATE TABLE AsciiTest (foo ascii PRIMARY KEY, bar ascii)');
				self::$connection->query(
						'INSERT INTO AsciiTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => 'barbaz']
				);
				$result = self::$connection->query('SELECT * FROM AsciiTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals('barbaz', $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
		}

		public function testAsciiMap()
		{
				self::$connection->query('CREATE TABLE AsciiMapTest (foo ascii PRIMARY KEY, bar map<ascii,ascii>)');
				self::$connection->query(
						'INSERT INTO AsciiMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz' => 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM AsciiMapTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz' => 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
		}

		public function testAsciiSet()
		{
				self::$connection->query('CREATE TABLE AsciiSetTest (foo ascii PRIMARY KEY, bar set<ascii>)');
				self::$connection->query(
						'INSERT INTO AsciiSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM AsciiSetTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO AsciiSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
				);
				$result = self::$connection->query('SELECT * FROM AsciiSetTest WHERE foo = :foo', ['foo' => 'baz2']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
		}

		public function testAsciiList()
		{
				self::$connection->query('CREATE TABLE AsciiListTest (foo ascii PRIMARY KEY, bar list<ascii>)');
				self::$connection->query(
						'INSERT INTO AsciiListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM AsciiListTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO AsciiListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
				);
				$result = self::$connection->query('SELECT * FROM AsciiListTest WHERE foo = :foo', ['foo' => 'baz2']);
				$this->assertEquals(['bazbar', 'barbaz'], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryBlobTest extends Setup\QueryTestCase
{

		public function testBlobColumn()
		{
				self::$connection->query('CREATE TABLE BlobTest (foo blob PRIMARY KEY, bar blob)');
				self::$connection->query('INSERT INTO BlobTest (foo, bar) VALUES (:foo, :bar)', ['foo' => '2', 'bar' => '52']);
				$result = self::$connection->query('SELECT * FROM BlobTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals('52', $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
		}

		public function testBlobMap()
		{
				self::$connection->query('CREATE TABLE BlobMapTest (foo blob PRIMARY KEY, bar map<blob,blob>)');
				self::$connection->query(
						'INSERT INTO BlobMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['52' => '25']]
				);
				$result = self::$connection->query('SELECT * FROM BlobMapTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals(['52' => '25'], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
		}

		public function testBlobSet()
		{
				self::$connection->query('CREATE TABLE BlobSetTest (foo blob PRIMARY KEY, bar set<blob>)');
				self::$connection->query(
						'INSERT INTO BlobSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['25', '52']]
				);
				$result = self::$connection->query('SELECT * FROM BlobSetTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals([25, 52], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO BlobSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '22', 'bar' => ['52', '25']]
				);
				$result = self::$connection->query('SELECT * FROM BlobSetTest WHERE foo = :foo', ['foo' => '22']);
				$this->assertEquals([25, 52], $result[0]['bar']);
		}

		public function testBlobList()
		{
				self::$connection->query('CREATE TABLE BlobListTest (foo blob PRIMARY KEY, bar list<blob>)');
				self::$connection->query(
						'INSERT INTO BlobListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['52', '25']]
				);
				$result = self::$connection->query('SELECT * FROM BlobListTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals(['52', '25'], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO BlobListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '22', 'bar' => ['25', '52']]
				);
				$result = self::$connection->query('SELECT * FROM BlobListTest WHERE foo = :foo', ['foo' => '22']);
				$this->assertEquals(['25', '52'], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryDoubleTest extends Setup\QueryTestCase
{

		public function testDoubleRow()
		{
				self::$connection->query('CREATE TABLE DoubleTest (foo double PRIMARY KEY, bar double)');
				self::$connection->query('INSERT INTO DoubleTest (foo, bar) VALUES (:foo, :bar)', ['foo' => 0.2, 'bar' => 5.2]);
				$result = self::$connection->query('SELECT * FROM DoubleTest WHERE foo = :foo', ['foo' => 0.2]);
				$this->assertFloatEquals(5.2, $result[0]['bar']);
				$this->assertFloatEquals(0.2, $result[0]['foo']);
		}

		public function testDoubleMap()
		{
				self::$connection->query('CREATE TABLE DoubleMapTest (foo double PRIMARY KEY, bar map<double,double>)');
				self::$connection->query(
						'INSERT INTO DoubleMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 0.2, 'bar' => [5.2 => 2.5]]
				);
				$result = self::$connection->query('SELECT * FROM DoubleMapTest WHERE foo = :foo', ['foo' => 0.2]);
				$this->assertFloatEquals([5.2 => 2.5], $result[0]['bar']);
				$this->assertFloatEquals(0.2, $result[0]['foo']);
		}

		public function testDoubleSet()
		{
				self::$connection->query('CREATE TABLE DoubleSetTest (foo double PRIMARY KEY, bar set<double>)');
				self::$connection->query(
						'INSERT INTO DoubleSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 0.2, 'bar' => [2.5, 5.2]]
				);
				$result = self::$connection->query('SELECT * FROM DoubleSetTest WHERE foo = :foo', ['foo' => 0.2]);
				$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
				$this->assertFloatEquals(0.2, $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO DoubleSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 2.2, 'bar' => [5.2, 2.5]]
				);
				$result = self::$connection->query('SELECT * FROM DoubleSetTest WHERE foo = :foo', ['foo' => 2.2]);
				$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
		}

		public function testDoubleList()
		{
				self::$connection->query('CREATE TABLE DoubleListTest (foo double PRIMARY KEY, bar list<double>)');
				self::$connection->query(
						'INSERT INTO DoubleListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 0.2, 'bar' => [5.2, 2.5]]
				);
				$result = self::$connection->query('SELECT * FROM DoubleListTest WHERE foo = :foo', ['foo' => 0.2]);
				$this->assertFloatEquals([5.2, 2.5], $result[0]['bar']);
				$this->assertFloatEquals(0.2, $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO DoubleListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 2.2, 'bar' => [2.5, 5.2]]
				);
				$result = self::$connection->query('SELECT * FROM DoubleListTest WHERE foo = :foo', ['foo' => 2.2]);
				$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryFloatTest extends Setup\QueryTestCase
{

		public function testFloatRow()
		{
				self::$connection->query('CREATE TABLE FloatTest (foo float PRIMARY KEY, bar float)');
				self::$connection->query('INSERT INTO FloatTest (foo, bar) VALUES (:foo, :bar)', ['foo' => 0.2, 'bar' => 5.2]);
				$result = self::$connection->query('SELECT * FROM FloatTest WHERE foo = :foo', ['foo' => 0.2]);
				$this->assertFloatEquals(5.2, $result[0]['bar']);
				$this->assertFloatEquals(0.2, $result[0]['foo']);
		}

		public function testFloatMap()
		{
				self::$connection->query('CREATE TABLE FloatMapTest (foo float PRIMARY KEY, bar map<float,float>)');
				self::$connection->query(
						'INSERT INTO FloatMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 0.2, 'bar' => [5.2 => 2.5]]
				);
				$result = self::$connection->query('SELECT * FROM FloatMapTest WHERE foo = :foo', ['foo' => 0.2]);
				$this->assertFloatEquals([5.2 => 2.5], $result[0]['bar']);
				$this->assertFloatEquals(0.2, $result[0]['foo']);
		}

		public function testFloatSet()
		{
				self::$connection->query('CREATE TABLE FloatSetTest (foo float PRIMARY KEY, bar set<float>)');
				self::$connection->query(
						'INSERT INTO FloatSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 0.2, 'bar' => [2.5, 5.2]]
				);
				$result = self::$connection->query('SELECT * FROM FloatSetTest WHERE foo = :foo', ['foo' => 0.2]);
				$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
				$this->assertFloatEquals(0.2, $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO FloatSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 2.2, 'bar' => [5.2, 2.5]]
				);
				$result = self::$connection->query('SELECT * FROM FloatSetTest WHERE foo = :foo', ['foo' => 2.2]);
				$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
		}

		public function testFloatList()
		{
				self::$connection->query('CREATE TABLE FloatListTest (foo float PRIMARY KEY, bar list<float>)');
				self::$connection->query(
						'INSERT INTO FloatListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 0.2, 'bar' => [5.2, 2.5]]
				);
				$result = self::$connection->query('SELECT * FROM FloatListTest WHERE foo = :foo', ['foo' => 0.2]);
				$this->assertFloatEquals([5.2, 2.5], $result[0]['bar']);
				$this->assertFloatEquals(0.2, $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO FloatListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 2.2, 'bar' => [2.5, 5.2]]
				);
				$result = self::$connection->query('SELECT * FROM FloatListTest WHERE foo = :foo', ['foo' => 2.2]);
				$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryInetTest extends Setup\QueryTestCase
{

		public function testInetColumn()
		{
				self::$connection->query('CREATE TABLE InetTest (foo inet PRIMARY KEY, bar inet)');
				self::$connection->query(
						'INSERT INTO InetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '192.168.1.2', 'bar' => '192.168.2.5']
				);
				$result = self::$connection->query('SELECT * FROM InetTest WHERE foo = :foo', ['foo' => '192.168.1.2']);
				$this->assertEquals('192.168.2.5', $result[0]['bar']);
				$this->assertEquals('192.168.1.2', $result[0]['foo']);
		}

		public function testInetMap()
		{
				self::$connection->query('CREATE TABLE InetMapTest (foo inet PRIMARY KEY, bar map<inet,inet>)');
				self::$connection->query(
						'INSERT INTO InetMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '192.168.1.2', 'bar' => ['192.168.2.5' => '192.68.2.16']]
				);
				$result = self::$connection->query('SELECT * FROM InetMapTest WHERE foo = :foo', ['foo' => '192.168.1.2']);
				$this->assertEquals(['192.168.2.5' => '192.68.2.16'], $result[0]['bar']);
				$this->assertEquals('192.168.1.2', $result[0]['foo']);
		}

		public function testInetSet()
		{
				self::$connection->query('CREATE TABLE InetSetTest (foo inet PRIMARY KEY, bar set<inet>)');
				self::$connection->query(
						'INSERT INTO InetSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '192.168.1.2', 'bar' => ['192.168.2.5', '2001:470:5284:201:d1c6:6f4a:b7c9:2f9e']]
				);
				$result = self::$connection->query('SELECT * FROM InetSetTest WHERE foo = :foo', ['foo' => '192.168.1.2']);
				$this->assertEquals(['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5'], $result[0]['bar']);
				$this->assertEquals('192.168.1.2', $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO InetSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '254.220.120.254', 'bar' => ['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5']]
				);
				$result = self::$connection->query('SELECT * FROM InetSetTest WHERE foo = :foo', ['foo' => '254.220.120.254']);
				$this->assertEquals(['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5'], $result[0]['bar']);
		}

		public function testInetList()
		{
				self::$connection->query('CREATE TABLE InetListTest (foo inet PRIMARY KEY, bar list<inet>)');
				self::$connection->query(
						'INSERT INTO InetListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '192.168.1.2', 'bar' => ['192.168.2.5', '2001:470:5284:201:d1c6:6f4a:b7c9:2f9e']]
				);
				$result = self::$connection->query('SELECT * FROM InetListTest WHERE foo = :foo', ['foo' => '192.168.1.2']);
				$this->assertEquals(['192.168.2.5', '2001:470:5284:201:d1c6:6f4a:b7c9:2f9e'], $result[0]['bar']);
				$this->assertEquals('192.168.1.2', $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO InetListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '254.220.120.254', 'bar' => ['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5']]
				);
				$result = self::$connection->query('SELECT * FROM InetListTest WHERE foo = :foo', ['foo' => '254.220.120.254']);
				$this->assertEquals(['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5'], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryPositiveBigIntTest extends Setup\QueryTestCase
{

		public function testBigIntRow()
		{
				self::$connection->query('CREATE TABLE BigIntTest (foo bigint PRIMARY KEY, bar bigint)');
				self::$connection->query(
						'INSERT INTO BigIntTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => '52']
				);
				$result = self::$connection->query('SELECT * FROM BigIntTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals('52', $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
		}

		public function testBigIntMap()
		{
				self::$connection->query('CREATE TABLE BigIntMapTest (foo bigint PRIMARY KEY, bar map<bigint,bigint>)');
				self::$connection->query(
						'INSERT INTO BigIntMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['52' => '25']]
				);
				$result = self::$connection->query('SELECT * FROM BigIntMapTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals(['52' => '25'], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
		}

		public function testBigIntSet()
		{
				self::$connection->query('CREATE TABLE BigIntSetTest (foo bigint PRIMARY KEY, bar set<bigint>)');
				self::$connection->query(
						'INSERT INTO BigIntSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['25', '52']]
				);
				$result = self::$connection->query('SELECT * FROM BigIntSetTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals([25, 52], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO BigIntSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '22', 'bar' => ['52', '25']]
				);
				$result = self::$connection->query('SELECT * FROM BigIntSetTest WHERE foo = :foo', ['foo' => '22']);
				$this->assertEquals([25, 52], $result[0]['bar']);
		}

		public function testBigIntList()
		{
				self::$connection->query('CREATE TABLE BigIntListTest (foo bigint PRIMARY KEY, bar list<bigint>)');
				self::$connection->query(
						'INSERT INTO BigIntListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['52', '25']]
				);
				$result = self::$connection->query('SELECT * FROM BigIntListTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals(['52', '25'], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO BigIntListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '22', 'bar' => ['25', '52']]
				);
				$result = self::$connection->query('SELECT * FROM BigIntListTest WHERE foo = :foo', ['foo' => '22']);
				$this->assertEquals(['25', '52'], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryPositiveIntTest extends Setup\QueryTestCase
{

		public function testIntRow()
		{
				self::$connection->query('CREATE TABLE IntTest (foo int PRIMARY KEY, bar int)');
				self::$connection->query('INSERT INTO IntTest (foo, bar) VALUES (:foo, :bar)', ['foo' => '2', 'bar' => '52']);
				$result = self::$connection->query('SELECT * FROM IntTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals('52', $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
		}

		public function testIntMap()
		{
				self::$connection->query('CREATE TABLE IntMapTest (foo int PRIMARY KEY, bar map<int,int>)');
				self::$connection->query(
						'INSERT INTO IntMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['52' => '25']]
				);
				$result = self::$connection->query('SELECT * FROM IntMapTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals(['52' => '25'], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
		}

		public function testIntSet()
		{
				self::$connection->query('CREATE TABLE IntSetTest (foo int PRIMARY KEY, bar set<int>)');
				self::$connection->query(
						'INSERT INTO IntSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['25', '52']]
				);
				$result = self::$connection->query('SELECT * FROM IntSetTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals([25, 52], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO IntSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '22', 'bar' => ['52', '25']]
				);
				$result = self::$connection->query('SELECT * FROM IntSetTest WHERE foo = :foo', ['foo' => '22']);
				$this->assertEquals([25, 52], $result[0]['bar']);
		}

		public function testIntList()
		{
				self::$connection->query('CREATE TABLE IntListTest (foo int PRIMARY KEY, bar list<int>)');
				self::$connection->query(
						'INSERT INTO IntListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '2', 'bar' => ['52', '25']]
				);
				$result = self::$connection->query('SELECT * FROM IntListTest WHERE foo = :foo', ['foo' => '2']);
				$this->assertEquals(['52', '25'], $result[0]['bar']);
				$this->assertEquals('2', $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO IntListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '22', 'bar' => ['25', '52']]
				);
				$result = self::$connection->query('SELECT * FROM IntListTest WHERE foo = :foo', ['foo' => '22']);
				$this->assertEquals(['25', '52'], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryTextTest extends Setup\QueryTestCase
{

		public function testTextColumn()
		{
				self::$connection->query('CREATE TABLE TextTest (foo text PRIMARY KEY, bar text)');
				self::$connection->query(
						'INSERT INTO TextTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => 'barbaz']
				);
				$result = self::$connection->query('SELECT * FROM TextTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals('barbaz', $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
		}

		public function testTextMap()
		{
				self::$connection->query('CREATE TABLE TextMapTest (foo text PRIMARY KEY, bar map<text,text>)');
				self::$connection->query(
						'INSERT INTO TextMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz' => 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM TextMapTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz' => 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
		}

		public function testTextSet()
		{
				self::$connection->query('CREATE TABLE TextSetTest (foo text PRIMARY KEY, bar set<text>)');
				self::$connection->query(
						'INSERT INTO TextSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM TextSetTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO TextSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
				);
				$result = self::$connection->query('SELECT * FROM TextSetTest WHERE foo = :foo', ['foo' => 'baz2']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
		}

		public function testTextList()
		{
				self::$connection->query('CREATE TABLE TextListTest (foo text PRIMARY KEY, bar list<text>)');
				self::$connection->query(
						'INSERT INTO TextListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM TextListTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO TextListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
				);
				$result = self::$connection->query('SELECT * FROM TextListTest WHERE foo = :foo', ['foo' => 'baz2']);
				$this->assertEquals(['bazbar', 'barbaz'], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryUuidTest extends Setup\QueryTestCase
{

		public function testUuidColumn()
		{
				self::$connection->query('CREATE TABLE UuidTest (foo uuid PRIMARY KEY, bar uuid)');
				self::$connection->query(
						'INSERT INTO UuidTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '456e4567-e89b-12d3-a456-426655440000', 'bar' => 'abce4567-e89b-12d3-a456-426655440000']
				);
				$result = self::$connection->query('SELECT * FROM UuidTest WHERE foo = :foo', ['foo' => '456e4567-e89b-12d3-a456-426655440000']);
				$this->assertEquals('abce4567-e89b-12d3-a456-426655440000', $result[0]['bar']);
				$this->assertEquals('456e4567-e89b-12d3-a456-426655440000', $result[0]['foo']);
		}

		public function testUuidMap()
		{
				self::$connection->query('CREATE TABLE UuidMapTest (foo uuid PRIMARY KEY, bar map<uuid,uuid>)');
				self::$connection->query(
						'INSERT INTO UuidMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '456e4567-e89b-12d3-a456-426655440000', 'bar' => ['abce4567-e89b-12d3-a456-426655440000' => 'cdfe4567-e89b-12d3-a456-426655440000']]
				);
				$result = self::$connection->query('SELECT * FROM UuidMapTest WHERE foo = :foo', ['foo' => '456e4567-e89b-12d3-a456-426655440000']);
				$this->assertEquals(['abce4567-e89b-12d3-a456-426655440000' => 'cdfe4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
				$this->assertEquals('456e4567-e89b-12d3-a456-426655440000', $result[0]['foo']);
		}

		public function testUuidSet()
		{
				self::$connection->query('CREATE TABLE UuidSetTest (foo uuid PRIMARY KEY, bar set<uuid>)');
				self::$connection->query(
						'INSERT INTO UuidSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '456e4567-e89b-12d3-a456-426655440000', 'bar' => ['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000']]
				);
				$result = self::$connection->query('SELECT * FROM UuidSetTest WHERE foo = :foo', ['foo' => '456e4567-e89b-12d3-a456-426655440000']);
				$this->assertEquals(['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
				$this->assertEquals('456e4567-e89b-12d3-a456-426655440000', $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO UuidSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '123e4567-e89b-12d3-a456-426655440000', 'bar' => ['cdfe4567-e89b-12d3-a456-426655440000', 'abce4567-e89b-12d3-a456-426655440000']]
				);
				$result = self::$connection->query('SELECT * FROM UuidSetTest WHERE foo = :foo', ['foo' => '123e4567-e89b-12d3-a456-426655440000']);
				$this->assertEquals(['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
		}

		public function testUuidList()
		{
				self::$connection->query('CREATE TABLE UuidListTest (foo uuid PRIMARY KEY, bar list<uuid>)');
				self::$connection->query(
						'INSERT INTO UuidListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '456e4567-e89b-12d3-a456-426655440000', 'bar' => ['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000']]
				);
				$result = self::$connection->query('SELECT * FROM UuidListTest WHERE foo = :foo', ['foo' => '456e4567-e89b-12d3-a456-426655440000']);
				$this->assertEquals(['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
				$this->assertEquals('456e4567-e89b-12d3-a456-426655440000', $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO UuidListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => '123e4567-e89b-12d3-a456-426655440000', 'bar' => ['cdfe4567-e89b-12d3-a456-426655440000', 'abce4567-e89b-12d3-a456-426655440000']]
				);
				$result = self::$connection->query('SELECT * FROM UuidListTest WHERE foo = :foo', ['foo' => '123e4567-e89b-12d3-a456-426655440000']);
				$this->assertEquals(['cdfe4567-e89b-12d3-a456-426655440000', 'abce4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
		}

}



use evseevnn\Cassandra;

class QueryVarcharTest extends Setup\QueryTestCase
{

		public function testVarcharColumn()
		{
				self::$connection->query('CREATE TABLE VarcharTest (foo varchar PRIMARY KEY, bar varchar)');
				self::$connection->query(
						'INSERT INTO VarcharTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => 'barbaz']
				);
				$result = self::$connection->query('SELECT * FROM VarcharTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals('barbaz', $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
		}

		public function testVarcharMap()
		{
				self::$connection->query('CREATE TABLE VarcharMapTest (foo varchar PRIMARY KEY, bar map<varchar,varchar>)');
				self::$connection->query(
						'INSERT INTO VarcharMapTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz' => 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM VarcharMapTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz' => 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
		}

		public function testVarcharSet()
		{
				self::$connection->query('CREATE TABLE VarcharSetTest (foo varchar PRIMARY KEY, bar set<varchar>)');
				self::$connection->query(
						'INSERT INTO VarcharSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM VarcharSetTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
				//according to Spec, this should always be returned alphabetically.
				self::$connection->query(
						'INSERT INTO VarcharSetTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
				);
				$result = self::$connection->query('SELECT * FROM VarcharSetTest WHERE foo = :foo', ['foo' => 'baz2']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
		}

		public function testVarcharList()
		{
				self::$connection->query('CREATE TABLE VarcharListTest (foo varchar PRIMARY KEY, bar list<varchar>)');
				self::$connection->query(
						'INSERT INTO VarcharListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
				);
				$result = self::$connection->query('SELECT * FROM VarcharListTest WHERE foo = :foo', ['foo' => 'baz']);
				$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
				$this->assertEquals('baz', $result[0]['foo']);
				//according to Spec, this should be returned in index order
				self::$connection->query(
						'INSERT INTO VarcharListTest (foo, bar) VALUES (:foo, :bar)',
						['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
				);
				$result = self::$connection->query('SELECT * FROM VarcharListTest WHERE foo = :foo', ['foo' => 'baz2']);
				$this->assertEquals(['bazbar', 'barbaz'], $result[0]['bar']);
		}

}

Code Duplication Length = 63-66 lines in 10 locations

tests/Cases/AsciiTest.php 1 location

tests/Cases/BlobTest.php 1 location

tests/Cases/DoubleTest.php 1 location

tests/Cases/FloatTest.php 1 location

tests/Cases/InetTest.php 1 location

tests/Cases/PositiveBigIntTest.php 1 location

tests/Cases/PositiveIntTest.php 1 location

tests/Cases/TextTest.php 1 location

tests/Cases/UuidTest.php 1 location

tests/Cases/VarcharTest.php 1 location

		@@ 7-72 (lines=66) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryAsciiTest extends Setup\QueryTestCase
8		{
9
10		public function testAsciiColumn()
11		{
12		self::$connection->query('CREATE TABLE AsciiTest (foo ascii PRIMARY KEY, bar ascii)');
13		self::$connection->query(
14		'INSERT INTO AsciiTest (foo, bar) VALUES (:foo, :bar)',
15		['foo' => 'baz', 'bar' => 'barbaz']
16		);
17		$result = self::$connection->query('SELECT * FROM AsciiTest WHERE foo = :foo', ['foo' => 'baz']);
18		$this->assertEquals('barbaz', $result[0]['bar']);
19		$this->assertEquals('baz', $result[0]['foo']);
20		}
21
22		public function testAsciiMap()
23		{
24		self::$connection->query('CREATE TABLE AsciiMapTest (foo ascii PRIMARY KEY, bar map<ascii,ascii>)');
25		self::$connection->query(
26		'INSERT INTO AsciiMapTest (foo, bar) VALUES (:foo, :bar)',
27		['foo' => 'baz', 'bar' => ['barbaz' => 'bazbar']]
28		);
29		$result = self::$connection->query('SELECT * FROM AsciiMapTest WHERE foo = :foo', ['foo' => 'baz']);
30		$this->assertEquals(['barbaz' => 'bazbar'], $result[0]['bar']);
31		$this->assertEquals('baz', $result[0]['foo']);
32		}
33
34		public function testAsciiSet()
35		{
36		self::$connection->query('CREATE TABLE AsciiSetTest (foo ascii PRIMARY KEY, bar set<ascii>)');
37		self::$connection->query(
38		'INSERT INTO AsciiSetTest (foo, bar) VALUES (:foo, :bar)',
39		['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
40		);
41		$result = self::$connection->query('SELECT * FROM AsciiSetTest WHERE foo = :foo', ['foo' => 'baz']);
42		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
43		$this->assertEquals('baz', $result[0]['foo']);
44		//according to Spec, this should always be returned alphabetically.
45		self::$connection->query(
46		'INSERT INTO AsciiSetTest (foo, bar) VALUES (:foo, :bar)',
47		['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
48		);
49		$result = self::$connection->query('SELECT * FROM AsciiSetTest WHERE foo = :foo', ['foo' => 'baz2']);
50		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
51		}
52
53		public function testAsciiList()
54		{
55		self::$connection->query('CREATE TABLE AsciiListTest (foo ascii PRIMARY KEY, bar list<ascii>)');
56		self::$connection->query(
57		'INSERT INTO AsciiListTest (foo, bar) VALUES (:foo, :bar)',
58		['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
59		);
60		$result = self::$connection->query('SELECT * FROM AsciiListTest WHERE foo = :foo', ['foo' => 'baz']);
61		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
62		$this->assertEquals('baz', $result[0]['foo']);
63		//according to Spec, this should be returned in index order
64		self::$connection->query(
65		'INSERT INTO AsciiListTest (foo, bar) VALUES (:foo, :bar)',
66		['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
67		);
68		$result = self::$connection->query('SELECT * FROM AsciiListTest WHERE foo = :foo', ['foo' => 'baz2']);
69		$this->assertEquals(['bazbar', 'barbaz'], $result[0]['bar']);
70		}
71
72		}

		@@ 7-69 (lines=63) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryBlobTest extends Setup\QueryTestCase
8		{
9
10		public function testBlobColumn()
11		{
12		self::$connection->query('CREATE TABLE BlobTest (foo blob PRIMARY KEY, bar blob)');
13		self::$connection->query('INSERT INTO BlobTest (foo, bar) VALUES (:foo, :bar)', ['foo' => '2', 'bar' => '52']);
14		$result = self::$connection->query('SELECT * FROM BlobTest WHERE foo = :foo', ['foo' => '2']);
15		$this->assertEquals('52', $result[0]['bar']);
16		$this->assertEquals('2', $result[0]['foo']);
17		}
18
19		public function testBlobMap()
20		{
21		self::$connection->query('CREATE TABLE BlobMapTest (foo blob PRIMARY KEY, bar map<blob,blob>)');
22		self::$connection->query(
23		'INSERT INTO BlobMapTest (foo, bar) VALUES (:foo, :bar)',
24		['foo' => '2', 'bar' => ['52' => '25']]
25		);
26		$result = self::$connection->query('SELECT * FROM BlobMapTest WHERE foo = :foo', ['foo' => '2']);
27		$this->assertEquals(['52' => '25'], $result[0]['bar']);
28		$this->assertEquals('2', $result[0]['foo']);
29		}
30
31		public function testBlobSet()
32		{
33		self::$connection->query('CREATE TABLE BlobSetTest (foo blob PRIMARY KEY, bar set<blob>)');
34		self::$connection->query(
35		'INSERT INTO BlobSetTest (foo, bar) VALUES (:foo, :bar)',
36		['foo' => '2', 'bar' => ['25', '52']]
37		);
38		$result = self::$connection->query('SELECT * FROM BlobSetTest WHERE foo = :foo', ['foo' => '2']);
39		$this->assertEquals([25, 52], $result[0]['bar']);
40		$this->assertEquals('2', $result[0]['foo']);
41		//according to Spec, this should always be returned alphabetically.
42		self::$connection->query(
43		'INSERT INTO BlobSetTest (foo, bar) VALUES (:foo, :bar)',
44		['foo' => '22', 'bar' => ['52', '25']]
45		);
46		$result = self::$connection->query('SELECT * FROM BlobSetTest WHERE foo = :foo', ['foo' => '22']);
47		$this->assertEquals([25, 52], $result[0]['bar']);
48		}
49
50		public function testBlobList()
51		{
52		self::$connection->query('CREATE TABLE BlobListTest (foo blob PRIMARY KEY, bar list<blob>)');
53		self::$connection->query(
54		'INSERT INTO BlobListTest (foo, bar) VALUES (:foo, :bar)',
55		['foo' => '2', 'bar' => ['52', '25']]
56		);
57		$result = self::$connection->query('SELECT * FROM BlobListTest WHERE foo = :foo', ['foo' => '2']);
58		$this->assertEquals(['52', '25'], $result[0]['bar']);
59		$this->assertEquals('2', $result[0]['foo']);
60		//according to Spec, this should be returned in index order
61		self::$connection->query(
62		'INSERT INTO BlobListTest (foo, bar) VALUES (:foo, :bar)',
63		['foo' => '22', 'bar' => ['25', '52']]
64		);
65		$result = self::$connection->query('SELECT * FROM BlobListTest WHERE foo = :foo', ['foo' => '22']);
66		$this->assertEquals(['25', '52'], $result[0]['bar']);
67		}
68
69		}

		@@ 7-69 (lines=63) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryDoubleTest extends Setup\QueryTestCase
8		{
9
10		public function testDoubleRow()
11		{
12		self::$connection->query('CREATE TABLE DoubleTest (foo double PRIMARY KEY, bar double)');
13		self::$connection->query('INSERT INTO DoubleTest (foo, bar) VALUES (:foo, :bar)', ['foo' => 0.2, 'bar' => 5.2]);
14		$result = self::$connection->query('SELECT * FROM DoubleTest WHERE foo = :foo', ['foo' => 0.2]);
15		$this->assertFloatEquals(5.2, $result[0]['bar']);
16		$this->assertFloatEquals(0.2, $result[0]['foo']);
17		}
18
19		public function testDoubleMap()
20		{
21		self::$connection->query('CREATE TABLE DoubleMapTest (foo double PRIMARY KEY, bar map<double,double>)');
22		self::$connection->query(
23		'INSERT INTO DoubleMapTest (foo, bar) VALUES (:foo, :bar)',
24		['foo' => 0.2, 'bar' => [5.2 => 2.5]]
25		);
26		$result = self::$connection->query('SELECT * FROM DoubleMapTest WHERE foo = :foo', ['foo' => 0.2]);
27		$this->assertFloatEquals([5.2 => 2.5], $result[0]['bar']);
28		$this->assertFloatEquals(0.2, $result[0]['foo']);
29		}
30
31		public function testDoubleSet()
32		{
33		self::$connection->query('CREATE TABLE DoubleSetTest (foo double PRIMARY KEY, bar set<double>)');
34		self::$connection->query(
35		'INSERT INTO DoubleSetTest (foo, bar) VALUES (:foo, :bar)',
36		['foo' => 0.2, 'bar' => [2.5, 5.2]]
37		);
38		$result = self::$connection->query('SELECT * FROM DoubleSetTest WHERE foo = :foo', ['foo' => 0.2]);
39		$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
40		$this->assertFloatEquals(0.2, $result[0]['foo']);
41		//according to Spec, this should always be returned alphabetically.
42		self::$connection->query(
43		'INSERT INTO DoubleSetTest (foo, bar) VALUES (:foo, :bar)',
44		['foo' => 2.2, 'bar' => [5.2, 2.5]]
45		);
46		$result = self::$connection->query('SELECT * FROM DoubleSetTest WHERE foo = :foo', ['foo' => 2.2]);
47		$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
48		}
49
50		public function testDoubleList()
51		{
52		self::$connection->query('CREATE TABLE DoubleListTest (foo double PRIMARY KEY, bar list<double>)');
53		self::$connection->query(
54		'INSERT INTO DoubleListTest (foo, bar) VALUES (:foo, :bar)',
55		['foo' => 0.2, 'bar' => [5.2, 2.5]]
56		);
57		$result = self::$connection->query('SELECT * FROM DoubleListTest WHERE foo = :foo', ['foo' => 0.2]);
58		$this->assertFloatEquals([5.2, 2.5], $result[0]['bar']);
59		$this->assertFloatEquals(0.2, $result[0]['foo']);
60		//according to Spec, this should be returned in index order
61		self::$connection->query(
62		'INSERT INTO DoubleListTest (foo, bar) VALUES (:foo, :bar)',
63		['foo' => 2.2, 'bar' => [2.5, 5.2]]
64		);
65		$result = self::$connection->query('SELECT * FROM DoubleListTest WHERE foo = :foo', ['foo' => 2.2]);
66		$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
67		}
68
69		}

		@@ 7-69 (lines=63) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryFloatTest extends Setup\QueryTestCase
8		{
9
10		public function testFloatRow()
11		{
12		self::$connection->query('CREATE TABLE FloatTest (foo float PRIMARY KEY, bar float)');
13		self::$connection->query('INSERT INTO FloatTest (foo, bar) VALUES (:foo, :bar)', ['foo' => 0.2, 'bar' => 5.2]);
14		$result = self::$connection->query('SELECT * FROM FloatTest WHERE foo = :foo', ['foo' => 0.2]);
15		$this->assertFloatEquals(5.2, $result[0]['bar']);
16		$this->assertFloatEquals(0.2, $result[0]['foo']);
17		}
18
19		public function testFloatMap()
20		{
21		self::$connection->query('CREATE TABLE FloatMapTest (foo float PRIMARY KEY, bar map<float,float>)');
22		self::$connection->query(
23		'INSERT INTO FloatMapTest (foo, bar) VALUES (:foo, :bar)',
24		['foo' => 0.2, 'bar' => [5.2 => 2.5]]
25		);
26		$result = self::$connection->query('SELECT * FROM FloatMapTest WHERE foo = :foo', ['foo' => 0.2]);
27		$this->assertFloatEquals([5.2 => 2.5], $result[0]['bar']);
28		$this->assertFloatEquals(0.2, $result[0]['foo']);
29		}
30
31		public function testFloatSet()
32		{
33		self::$connection->query('CREATE TABLE FloatSetTest (foo float PRIMARY KEY, bar set<float>)');
34		self::$connection->query(
35		'INSERT INTO FloatSetTest (foo, bar) VALUES (:foo, :bar)',
36		['foo' => 0.2, 'bar' => [2.5, 5.2]]
37		);
38		$result = self::$connection->query('SELECT * FROM FloatSetTest WHERE foo = :foo', ['foo' => 0.2]);
39		$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
40		$this->assertFloatEquals(0.2, $result[0]['foo']);
41		//according to Spec, this should always be returned alphabetically.
42		self::$connection->query(
43		'INSERT INTO FloatSetTest (foo, bar) VALUES (:foo, :bar)',
44		['foo' => 2.2, 'bar' => [5.2, 2.5]]
45		);
46		$result = self::$connection->query('SELECT * FROM FloatSetTest WHERE foo = :foo', ['foo' => 2.2]);
47		$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
48		}
49
50		public function testFloatList()
51		{
52		self::$connection->query('CREATE TABLE FloatListTest (foo float PRIMARY KEY, bar list<float>)');
53		self::$connection->query(
54		'INSERT INTO FloatListTest (foo, bar) VALUES (:foo, :bar)',
55		['foo' => 0.2, 'bar' => [5.2, 2.5]]
56		);
57		$result = self::$connection->query('SELECT * FROM FloatListTest WHERE foo = :foo', ['foo' => 0.2]);
58		$this->assertFloatEquals([5.2, 2.5], $result[0]['bar']);
59		$this->assertFloatEquals(0.2, $result[0]['foo']);
60		//according to Spec, this should be returned in index order
61		self::$connection->query(
62		'INSERT INTO FloatListTest (foo, bar) VALUES (:foo, :bar)',
63		['foo' => 2.2, 'bar' => [2.5, 5.2]]
64		);
65		$result = self::$connection->query('SELECT * FROM FloatListTest WHERE foo = :foo', ['foo' => 2.2]);
66		$this->assertFloatEquals([2.5, 5.2], $result[0]['bar']);
67		}
68
69		}

		@@ 7-72 (lines=66) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryInetTest extends Setup\QueryTestCase
8		{
9
10		public function testInetColumn()
11		{
12		self::$connection->query('CREATE TABLE InetTest (foo inet PRIMARY KEY, bar inet)');
13		self::$connection->query(
14		'INSERT INTO InetTest (foo, bar) VALUES (:foo, :bar)',
15		['foo' => '192.168.1.2', 'bar' => '192.168.2.5']
16		);
17		$result = self::$connection->query('SELECT * FROM InetTest WHERE foo = :foo', ['foo' => '192.168.1.2']);
18		$this->assertEquals('192.168.2.5', $result[0]['bar']);
19		$this->assertEquals('192.168.1.2', $result[0]['foo']);
20		}
21
22		public function testInetMap()
23		{
24		self::$connection->query('CREATE TABLE InetMapTest (foo inet PRIMARY KEY, bar map<inet,inet>)');
25		self::$connection->query(
26		'INSERT INTO InetMapTest (foo, bar) VALUES (:foo, :bar)',
27		['foo' => '192.168.1.2', 'bar' => ['192.168.2.5' => '192.68.2.16']]
28		);
29		$result = self::$connection->query('SELECT * FROM InetMapTest WHERE foo = :foo', ['foo' => '192.168.1.2']);
30		$this->assertEquals(['192.168.2.5' => '192.68.2.16'], $result[0]['bar']);
31		$this->assertEquals('192.168.1.2', $result[0]['foo']);
32		}
33
34		public function testInetSet()
35		{
36		self::$connection->query('CREATE TABLE InetSetTest (foo inet PRIMARY KEY, bar set<inet>)');
37		self::$connection->query(
38		'INSERT INTO InetSetTest (foo, bar) VALUES (:foo, :bar)',
39		['foo' => '192.168.1.2', 'bar' => ['192.168.2.5', '2001:470:5284:201:d1c6:6f4a:b7c9:2f9e']]
40		);
41		$result = self::$connection->query('SELECT * FROM InetSetTest WHERE foo = :foo', ['foo' => '192.168.1.2']);
42		$this->assertEquals(['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5'], $result[0]['bar']);
43		$this->assertEquals('192.168.1.2', $result[0]['foo']);
44		//according to Spec, this should always be returned alphabetically.
45		self::$connection->query(
46		'INSERT INTO InetSetTest (foo, bar) VALUES (:foo, :bar)',
47		['foo' => '254.220.120.254', 'bar' => ['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5']]
48		);
49		$result = self::$connection->query('SELECT * FROM InetSetTest WHERE foo = :foo', ['foo' => '254.220.120.254']);
50		$this->assertEquals(['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5'], $result[0]['bar']);
51		}
52
53		public function testInetList()
54		{
55		self::$connection->query('CREATE TABLE InetListTest (foo inet PRIMARY KEY, bar list<inet>)');
56		self::$connection->query(
57		'INSERT INTO InetListTest (foo, bar) VALUES (:foo, :bar)',
58		['foo' => '192.168.1.2', 'bar' => ['192.168.2.5', '2001:470:5284:201:d1c6:6f4a:b7c9:2f9e']]
59		);
60		$result = self::$connection->query('SELECT * FROM InetListTest WHERE foo = :foo', ['foo' => '192.168.1.2']);
61		$this->assertEquals(['192.168.2.5', '2001:470:5284:201:d1c6:6f4a:b7c9:2f9e'], $result[0]['bar']);
62		$this->assertEquals('192.168.1.2', $result[0]['foo']);
63		//according to Spec, this should be returned in index order
64		self::$connection->query(
65		'INSERT INTO InetListTest (foo, bar) VALUES (:foo, :bar)',
66		['foo' => '254.220.120.254', 'bar' => ['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5']]
67		);
68		$result = self::$connection->query('SELECT * FROM InetListTest WHERE foo = :foo', ['foo' => '254.220.120.254']);
69		$this->assertEquals(['2001:470:5284:201:d1c6:6f4a:b7c9:2f9e', '192.168.2.5'], $result[0]['bar']);
70		}
71
72		}

		@@ 7-72 (lines=66) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryPositiveBigIntTest extends Setup\QueryTestCase
8		{
9
10		public function testBigIntRow()
11		{
12		self::$connection->query('CREATE TABLE BigIntTest (foo bigint PRIMARY KEY, bar bigint)');
13		self::$connection->query(
14		'INSERT INTO BigIntTest (foo, bar) VALUES (:foo, :bar)',
15		['foo' => '2', 'bar' => '52']
16		);
17		$result = self::$connection->query('SELECT * FROM BigIntTest WHERE foo = :foo', ['foo' => '2']);
18		$this->assertEquals('52', $result[0]['bar']);
19		$this->assertEquals('2', $result[0]['foo']);
20		}
21
22		public function testBigIntMap()
23		{
24		self::$connection->query('CREATE TABLE BigIntMapTest (foo bigint PRIMARY KEY, bar map<bigint,bigint>)');
25		self::$connection->query(
26		'INSERT INTO BigIntMapTest (foo, bar) VALUES (:foo, :bar)',
27		['foo' => '2', 'bar' => ['52' => '25']]
28		);
29		$result = self::$connection->query('SELECT * FROM BigIntMapTest WHERE foo = :foo', ['foo' => '2']);
30		$this->assertEquals(['52' => '25'], $result[0]['bar']);
31		$this->assertEquals('2', $result[0]['foo']);
32		}
33
34		public function testBigIntSet()
35		{
36		self::$connection->query('CREATE TABLE BigIntSetTest (foo bigint PRIMARY KEY, bar set<bigint>)');
37		self::$connection->query(
38		'INSERT INTO BigIntSetTest (foo, bar) VALUES (:foo, :bar)',
39		['foo' => '2', 'bar' => ['25', '52']]
40		);
41		$result = self::$connection->query('SELECT * FROM BigIntSetTest WHERE foo = :foo', ['foo' => '2']);
42		$this->assertEquals([25, 52], $result[0]['bar']);
43		$this->assertEquals('2', $result[0]['foo']);
44		//according to Spec, this should always be returned alphabetically.
45		self::$connection->query(
46		'INSERT INTO BigIntSetTest (foo, bar) VALUES (:foo, :bar)',
47		['foo' => '22', 'bar' => ['52', '25']]
48		);
49		$result = self::$connection->query('SELECT * FROM BigIntSetTest WHERE foo = :foo', ['foo' => '22']);
50		$this->assertEquals([25, 52], $result[0]['bar']);
51		}
52
53		public function testBigIntList()
54		{
55		self::$connection->query('CREATE TABLE BigIntListTest (foo bigint PRIMARY KEY, bar list<bigint>)');
56		self::$connection->query(
57		'INSERT INTO BigIntListTest (foo, bar) VALUES (:foo, :bar)',
58		['foo' => '2', 'bar' => ['52', '25']]
59		);
60		$result = self::$connection->query('SELECT * FROM BigIntListTest WHERE foo = :foo', ['foo' => '2']);
61		$this->assertEquals(['52', '25'], $result[0]['bar']);
62		$this->assertEquals('2', $result[0]['foo']);
63		//according to Spec, this should be returned in index order
64		self::$connection->query(
65		'INSERT INTO BigIntListTest (foo, bar) VALUES (:foo, :bar)',
66		['foo' => '22', 'bar' => ['25', '52']]
67		);
68		$result = self::$connection->query('SELECT * FROM BigIntListTest WHERE foo = :foo', ['foo' => '22']);
69		$this->assertEquals(['25', '52'], $result[0]['bar']);
70		}
71
72		}

		@@ 7-69 (lines=63) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryPositiveIntTest extends Setup\QueryTestCase
8		{
9
10		public function testIntRow()
11		{
12		self::$connection->query('CREATE TABLE IntTest (foo int PRIMARY KEY, bar int)');
13		self::$connection->query('INSERT INTO IntTest (foo, bar) VALUES (:foo, :bar)', ['foo' => '2', 'bar' => '52']);
14		$result = self::$connection->query('SELECT * FROM IntTest WHERE foo = :foo', ['foo' => '2']);
15		$this->assertEquals('52', $result[0]['bar']);
16		$this->assertEquals('2', $result[0]['foo']);
17		}
18
19		public function testIntMap()
20		{
21		self::$connection->query('CREATE TABLE IntMapTest (foo int PRIMARY KEY, bar map<int,int>)');
22		self::$connection->query(
23		'INSERT INTO IntMapTest (foo, bar) VALUES (:foo, :bar)',
24		['foo' => '2', 'bar' => ['52' => '25']]
25		);
26		$result = self::$connection->query('SELECT * FROM IntMapTest WHERE foo = :foo', ['foo' => '2']);
27		$this->assertEquals(['52' => '25'], $result[0]['bar']);
28		$this->assertEquals('2', $result[0]['foo']);
29		}
30
31		public function testIntSet()
32		{
33		self::$connection->query('CREATE TABLE IntSetTest (foo int PRIMARY KEY, bar set<int>)');
34		self::$connection->query(
35		'INSERT INTO IntSetTest (foo, bar) VALUES (:foo, :bar)',
36		['foo' => '2', 'bar' => ['25', '52']]
37		);
38		$result = self::$connection->query('SELECT * FROM IntSetTest WHERE foo = :foo', ['foo' => '2']);
39		$this->assertEquals([25, 52], $result[0]['bar']);
40		$this->assertEquals('2', $result[0]['foo']);
41		//according to Spec, this should always be returned alphabetically.
42		self::$connection->query(
43		'INSERT INTO IntSetTest (foo, bar) VALUES (:foo, :bar)',
44		['foo' => '22', 'bar' => ['52', '25']]
45		);
46		$result = self::$connection->query('SELECT * FROM IntSetTest WHERE foo = :foo', ['foo' => '22']);
47		$this->assertEquals([25, 52], $result[0]['bar']);
48		}
49
50		public function testIntList()
51		{
52		self::$connection->query('CREATE TABLE IntListTest (foo int PRIMARY KEY, bar list<int>)');
53		self::$connection->query(
54		'INSERT INTO IntListTest (foo, bar) VALUES (:foo, :bar)',
55		['foo' => '2', 'bar' => ['52', '25']]
56		);
57		$result = self::$connection->query('SELECT * FROM IntListTest WHERE foo = :foo', ['foo' => '2']);
58		$this->assertEquals(['52', '25'], $result[0]['bar']);
59		$this->assertEquals('2', $result[0]['foo']);
60		//according to Spec, this should be returned in index order
61		self::$connection->query(
62		'INSERT INTO IntListTest (foo, bar) VALUES (:foo, :bar)',
63		['foo' => '22', 'bar' => ['25', '52']]
64		);
65		$result = self::$connection->query('SELECT * FROM IntListTest WHERE foo = :foo', ['foo' => '22']);
66		$this->assertEquals(['25', '52'], $result[0]['bar']);
67		}
68
69		}

		@@ 7-72 (lines=66) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryTextTest extends Setup\QueryTestCase
8		{
9
10		public function testTextColumn()
11		{
12		self::$connection->query('CREATE TABLE TextTest (foo text PRIMARY KEY, bar text)');
13		self::$connection->query(
14		'INSERT INTO TextTest (foo, bar) VALUES (:foo, :bar)',
15		['foo' => 'baz', 'bar' => 'barbaz']
16		);
17		$result = self::$connection->query('SELECT * FROM TextTest WHERE foo = :foo', ['foo' => 'baz']);
18		$this->assertEquals('barbaz', $result[0]['bar']);
19		$this->assertEquals('baz', $result[0]['foo']);
20		}
21
22		public function testTextMap()
23		{
24		self::$connection->query('CREATE TABLE TextMapTest (foo text PRIMARY KEY, bar map<text,text>)');
25		self::$connection->query(
26		'INSERT INTO TextMapTest (foo, bar) VALUES (:foo, :bar)',
27		['foo' => 'baz', 'bar' => ['barbaz' => 'bazbar']]
28		);
29		$result = self::$connection->query('SELECT * FROM TextMapTest WHERE foo = :foo', ['foo' => 'baz']);
30		$this->assertEquals(['barbaz' => 'bazbar'], $result[0]['bar']);
31		$this->assertEquals('baz', $result[0]['foo']);
32		}
33
34		public function testTextSet()
35		{
36		self::$connection->query('CREATE TABLE TextSetTest (foo text PRIMARY KEY, bar set<text>)');
37		self::$connection->query(
38		'INSERT INTO TextSetTest (foo, bar) VALUES (:foo, :bar)',
39		['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
40		);
41		$result = self::$connection->query('SELECT * FROM TextSetTest WHERE foo = :foo', ['foo' => 'baz']);
42		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
43		$this->assertEquals('baz', $result[0]['foo']);
44		//according to Spec, this should always be returned alphabetically.
45		self::$connection->query(
46		'INSERT INTO TextSetTest (foo, bar) VALUES (:foo, :bar)',
47		['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
48		);
49		$result = self::$connection->query('SELECT * FROM TextSetTest WHERE foo = :foo', ['foo' => 'baz2']);
50		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
51		}
52
53		public function testTextList()
54		{
55		self::$connection->query('CREATE TABLE TextListTest (foo text PRIMARY KEY, bar list<text>)');
56		self::$connection->query(
57		'INSERT INTO TextListTest (foo, bar) VALUES (:foo, :bar)',
58		['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
59		);
60		$result = self::$connection->query('SELECT * FROM TextListTest WHERE foo = :foo', ['foo' => 'baz']);
61		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
62		$this->assertEquals('baz', $result[0]['foo']);
63		//according to Spec, this should be returned in index order
64		self::$connection->query(
65		'INSERT INTO TextListTest (foo, bar) VALUES (:foo, :bar)',
66		['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
67		);
68		$result = self::$connection->query('SELECT * FROM TextListTest WHERE foo = :foo', ['foo' => 'baz2']);
69		$this->assertEquals(['bazbar', 'barbaz'], $result[0]['bar']);
70		}
71
72		}

		@@ 7-72 (lines=66) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryUuidTest extends Setup\QueryTestCase
8		{
9
10		public function testUuidColumn()
11		{
12		self::$connection->query('CREATE TABLE UuidTest (foo uuid PRIMARY KEY, bar uuid)');
13		self::$connection->query(
14		'INSERT INTO UuidTest (foo, bar) VALUES (:foo, :bar)',
15		['foo' => '456e4567-e89b-12d3-a456-426655440000', 'bar' => 'abce4567-e89b-12d3-a456-426655440000']
16		);
17		$result = self::$connection->query('SELECT * FROM UuidTest WHERE foo = :foo', ['foo' => '456e4567-e89b-12d3-a456-426655440000']);
18		$this->assertEquals('abce4567-e89b-12d3-a456-426655440000', $result[0]['bar']);
19		$this->assertEquals('456e4567-e89b-12d3-a456-426655440000', $result[0]['foo']);
20		}
21
22		public function testUuidMap()
23		{
24		self::$connection->query('CREATE TABLE UuidMapTest (foo uuid PRIMARY KEY, bar map<uuid,uuid>)');
25		self::$connection->query(
26		'INSERT INTO UuidMapTest (foo, bar) VALUES (:foo, :bar)',
27		['foo' => '456e4567-e89b-12d3-a456-426655440000', 'bar' => ['abce4567-e89b-12d3-a456-426655440000' => 'cdfe4567-e89b-12d3-a456-426655440000']]
28		);
29		$result = self::$connection->query('SELECT * FROM UuidMapTest WHERE foo = :foo', ['foo' => '456e4567-e89b-12d3-a456-426655440000']);
30		$this->assertEquals(['abce4567-e89b-12d3-a456-426655440000' => 'cdfe4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
31		$this->assertEquals('456e4567-e89b-12d3-a456-426655440000', $result[0]['foo']);
32		}
33
34		public function testUuidSet()
35		{
36		self::$connection->query('CREATE TABLE UuidSetTest (foo uuid PRIMARY KEY, bar set<uuid>)');
37		self::$connection->query(
38		'INSERT INTO UuidSetTest (foo, bar) VALUES (:foo, :bar)',
39		['foo' => '456e4567-e89b-12d3-a456-426655440000', 'bar' => ['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000']]
40		);
41		$result = self::$connection->query('SELECT * FROM UuidSetTest WHERE foo = :foo', ['foo' => '456e4567-e89b-12d3-a456-426655440000']);
42		$this->assertEquals(['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
43		$this->assertEquals('456e4567-e89b-12d3-a456-426655440000', $result[0]['foo']);
44		//according to Spec, this should always be returned alphabetically.
45		self::$connection->query(
46		'INSERT INTO UuidSetTest (foo, bar) VALUES (:foo, :bar)',
47		['foo' => '123e4567-e89b-12d3-a456-426655440000', 'bar' => ['cdfe4567-e89b-12d3-a456-426655440000', 'abce4567-e89b-12d3-a456-426655440000']]
48		);
49		$result = self::$connection->query('SELECT * FROM UuidSetTest WHERE foo = :foo', ['foo' => '123e4567-e89b-12d3-a456-426655440000']);
50		$this->assertEquals(['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
51		}
52
53		public function testUuidList()
54		{
55		self::$connection->query('CREATE TABLE UuidListTest (foo uuid PRIMARY KEY, bar list<uuid>)');
56		self::$connection->query(
57		'INSERT INTO UuidListTest (foo, bar) VALUES (:foo, :bar)',
58		['foo' => '456e4567-e89b-12d3-a456-426655440000', 'bar' => ['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000']]
59		);
60		$result = self::$connection->query('SELECT * FROM UuidListTest WHERE foo = :foo', ['foo' => '456e4567-e89b-12d3-a456-426655440000']);
61		$this->assertEquals(['abce4567-e89b-12d3-a456-426655440000', 'cdfe4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
62		$this->assertEquals('456e4567-e89b-12d3-a456-426655440000', $result[0]['foo']);
63		//according to Spec, this should be returned in index order
64		self::$connection->query(
65		'INSERT INTO UuidListTest (foo, bar) VALUES (:foo, :bar)',
66		['foo' => '123e4567-e89b-12d3-a456-426655440000', 'bar' => ['cdfe4567-e89b-12d3-a456-426655440000', 'abce4567-e89b-12d3-a456-426655440000']]
67		);
68		$result = self::$connection->query('SELECT * FROM UuidListTest WHERE foo = :foo', ['foo' => '123e4567-e89b-12d3-a456-426655440000']);
69		$this->assertEquals(['cdfe4567-e89b-12d3-a456-426655440000', 'abce4567-e89b-12d3-a456-426655440000'], $result[0]['bar']);
70		}
71
72		}

		@@ 7-72 (lines=66) @@
4
5		use evseevnn\Cassandra;
6
7		class QueryVarcharTest extends Setup\QueryTestCase
8		{
9
10		public function testVarcharColumn()
11		{
12		self::$connection->query('CREATE TABLE VarcharTest (foo varchar PRIMARY KEY, bar varchar)');
13		self::$connection->query(
14		'INSERT INTO VarcharTest (foo, bar) VALUES (:foo, :bar)',
15		['foo' => 'baz', 'bar' => 'barbaz']
16		);
17		$result = self::$connection->query('SELECT * FROM VarcharTest WHERE foo = :foo', ['foo' => 'baz']);
18		$this->assertEquals('barbaz', $result[0]['bar']);
19		$this->assertEquals('baz', $result[0]['foo']);
20		}
21
22		public function testVarcharMap()
23		{
24		self::$connection->query('CREATE TABLE VarcharMapTest (foo varchar PRIMARY KEY, bar map<varchar,varchar>)');
25		self::$connection->query(
26		'INSERT INTO VarcharMapTest (foo, bar) VALUES (:foo, :bar)',
27		['foo' => 'baz', 'bar' => ['barbaz' => 'bazbar']]
28		);
29		$result = self::$connection->query('SELECT * FROM VarcharMapTest WHERE foo = :foo', ['foo' => 'baz']);
30		$this->assertEquals(['barbaz' => 'bazbar'], $result[0]['bar']);
31		$this->assertEquals('baz', $result[0]['foo']);
32		}
33
34		public function testVarcharSet()
35		{
36		self::$connection->query('CREATE TABLE VarcharSetTest (foo varchar PRIMARY KEY, bar set<varchar>)');
37		self::$connection->query(
38		'INSERT INTO VarcharSetTest (foo, bar) VALUES (:foo, :bar)',
39		['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
40		);
41		$result = self::$connection->query('SELECT * FROM VarcharSetTest WHERE foo = :foo', ['foo' => 'baz']);
42		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
43		$this->assertEquals('baz', $result[0]['foo']);
44		//according to Spec, this should always be returned alphabetically.
45		self::$connection->query(
46		'INSERT INTO VarcharSetTest (foo, bar) VALUES (:foo, :bar)',
47		['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
48		);
49		$result = self::$connection->query('SELECT * FROM VarcharSetTest WHERE foo = :foo', ['foo' => 'baz2']);
50		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
51		}
52
53		public function testVarcharList()
54		{
55		self::$connection->query('CREATE TABLE VarcharListTest (foo varchar PRIMARY KEY, bar list<varchar>)');
56		self::$connection->query(
57		'INSERT INTO VarcharListTest (foo, bar) VALUES (:foo, :bar)',
58		['foo' => 'baz', 'bar' => ['barbaz', 'bazbar']]
59		);
60		$result = self::$connection->query('SELECT * FROM VarcharListTest WHERE foo = :foo', ['foo' => 'baz']);
61		$this->assertEquals(['barbaz', 'bazbar'], $result[0]['bar']);
62		$this->assertEquals('baz', $result[0]['foo']);
63		//according to Spec, this should be returned in index order
64		self::$connection->query(
65		'INSERT INTO VarcharListTest (foo, bar) VALUES (:foo, :bar)',
66		['foo' => 'baz2', 'bar' => ['bazbar', 'barbaz']]
67		);
68		$result = self::$connection->query('SELECT * FROM VarcharListTest WHERE foo = :foo', ['foo' => 'baz2']);
69		$this->assertEquals(['bazbar', 'barbaz'], $result[0]['bar']);
70		}
71
72		}

evseevnn / php-cassandra-binary

Code Duplication Length = 63-66 lines in 10 locations

tests/Cases/AsciiTest.php 1 location

tests/Cases/BlobTest.php 1 location

tests/Cases/DoubleTest.php 1 location

tests/Cases/FloatTest.php 1 location

tests/Cases/InetTest.php 1 location

tests/Cases/PositiveBigIntTest.php 1 location

tests/Cases/PositiveIntTest.php 1 location

tests/Cases/TextTest.php 1 location

tests/Cases/UuidTest.php 1 location

tests/Cases/VarcharTest.php 1 location