// jsobjtests.cpp - Tests for jsobj.{h,cpp} code // /** * Copyright (C) 2008 10gen Inc. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License, version 3, * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ #include "pch.h" #include "../bson/util/builder.h" #include "../db/jsobj.h" #include "../db/jsobjmanipulator.h" #include "../db/json.h" #include "../db/repl.h" #include "../db/extsort.h" #include "dbtests.h" #include "../util/mongoutils/checksum.h" #include "../db/key.h" #include "../db/btree.h" namespace JsobjTests { void keyTest(const BSONObj& o, bool mustBeCompact = false) { static KeyV1Owned *kLast; static BSONObj last; KeyV1Owned *key = new KeyV1Owned(o); KeyV1Owned& k = *key; ASSERT( !mustBeCompact || k.isCompactFormat() ); BSONObj x = k.toBson(); int res = o.woCompare(x, BSONObj(), /*considerfieldname*/false); if( res ) { cout << o.toString() << endl; k.toBson(); cout << x.toString() << endl; o.woCompare(x, BSONObj(), /*considerfieldname*/false); ASSERT( res == 0 ); } ASSERT( k.woEqual(k) ); ASSERT( !k.isCompactFormat() || k.dataSize() < o.objsize() ); { // check BSONObj::equal. this part not a KeyV1 test. int res = o.woCompare(last); ASSERT( (res==0) == o.equal(last) ); } if( kLast ) { int r1 = o.woCompare(last, BSONObj(), false); int r2 = k.woCompare(*kLast, Ordering::make(BSONObj())); bool ok = (r1<0 && r2<0) || (r1>0&&r2>0) || r1==r2; if( !ok ) { cout << "r1r2 " << r1 << ' ' << r2 << endl; cout << "o:" << o.toString() << endl; cout << "last:" << last.toString() << endl; cout << "k:" << k.toString() << endl; cout << "kLast:" << kLast->toString() << endl; int r3 = k.woCompare(*kLast, Ordering::make(BSONObj())); cout << r3 << endl; } ASSERT(ok); if( k.isCompactFormat() && kLast->isCompactFormat() ) { // only check if not bson as bson woEqual is broken! (or was may2011) if( k.woEqual(*kLast) != (r2 == 0) ) { // check woEqual matches cout << r2 << endl; cout << k.toString() << endl; cout << kLast->toString() << endl; k.woEqual(*kLast); ASSERT(false); } } } delete kLast; kLast = key; last = o.getOwned(); } class BufBuilderBasic { public: void run() { { BufBuilder b( 0 ); b.appendStr( "foo" ); ASSERT_EQUALS( 4, b.len() ); ASSERT( strcmp( "foo", b.buf() ) == 0 ); } { mongo::StackBufBuilder b; b.appendStr( "foo" ); ASSERT_EQUALS( 4, b.len() ); ASSERT( strcmp( "foo", b.buf() ) == 0 ); } } }; class BSONElementBasic { public: void run() { ASSERT_EQUALS( 1, BSONElement().size() ); BSONObj x; ASSERT_EQUALS( 1, x.firstElement().size() ); } }; namespace BSONObjTests { class Create { public: void run() { BSONObj b; ASSERT_EQUALS( 0, b.nFields() ); } }; class Base { protected: static BSONObj basic( const char *name, int val ) { BSONObjBuilder b; b.append( name, val ); return b.obj(); } static BSONObj basic( const char *name, vector< int > val ) { BSONObjBuilder b; b.append( name, val ); return b.obj(); } template< class T > static BSONObj basic( const char *name, T val ) { BSONObjBuilder b; b.append( name, val ); return b.obj(); } }; class WoCompareBasic : public Base { public: void run() { ASSERT( basic( "a", 1 ).woCompare( basic( "a", 1 ) ) == 0 ); ASSERT( basic( "a", 2 ).woCompare( basic( "a", 1 ) ) > 0 ); ASSERT( basic( "a", 1 ).woCompare( basic( "a", 2 ) ) < 0 ); // field name comparison ASSERT( basic( "a", 1 ).woCompare( basic( "b", 1 ) ) < 0 ); } }; class NumericCompareBasic : public Base { public: void run() { ASSERT( basic( "a", 1 ).woCompare( basic( "a", 1.0 ) ) == 0 ); } }; class WoCompareEmbeddedObject : public Base { public: void run() { ASSERT( basic( "a", basic( "b", 1 ) ).woCompare ( basic( "a", basic( "b", 1.0 ) ) ) == 0 ); ASSERT( basic( "a", basic( "b", 1 ) ).woCompare ( basic( "a", basic( "b", 2 ) ) ) < 0 ); } }; class WoCompareEmbeddedArray : public Base { public: void run() { vector< int > i; i.push_back( 1 ); i.push_back( 2 ); vector< double > d; d.push_back( 1 ); d.push_back( 2 ); ASSERT( basic( "a", i ).woCompare( basic( "a", d ) ) == 0 ); vector< int > j; j.push_back( 1 ); j.push_back( 3 ); ASSERT( basic( "a", i ).woCompare( basic( "a", j ) ) < 0 ); } }; class WoCompareOrdered : public Base { public: void run() { ASSERT( basic( "a", 1 ).woCompare( basic( "a", 1 ), basic( "a", 1 ) ) == 0 ); ASSERT( basic( "a", 2 ).woCompare( basic( "a", 1 ), basic( "a", 1 ) ) > 0 ); ASSERT( basic( "a", 1 ).woCompare( basic( "a", 2 ), basic( "a", 1 ) ) < 0 ); ASSERT( basic( "a", 1 ).woCompare( basic( "a", 1 ), basic( "a", -1 ) ) == 0 ); ASSERT( basic( "a", 2 ).woCompare( basic( "a", 1 ), basic( "a", -1 ) ) < 0 ); ASSERT( basic( "a", 1 ).woCompare( basic( "a", 2 ), basic( "a", -1 ) ) > 0 ); } }; class WoCompareDifferentLength : public Base { public: void run() { ASSERT( BSON( "a" << 1 ).woCompare( BSON( "a" << 1 << "b" << 1 ) ) < 0 ); ASSERT( BSON( "a" << 1 << "b" << 1 ).woCompare( BSON( "a" << 1 ) ) > 0 ); } }; class WoSortOrder : public Base { public: void run() { ASSERT( BSON( "a" << 1 ).woSortOrder( BSON( "a" << 2 ), BSON( "b" << 1 << "a" << 1 ) ) < 0 ); ASSERT( fromjson( "{a:null}" ).woSortOrder( BSON( "b" << 1 ), BSON( "a" << 1 ) ) == 0 ); } }; class MultiKeySortOrder : public Base { public: void run() { ASSERT( BSON( "x" << "a" ).woCompare( BSON( "x" << "b" ) ) < 0 ); ASSERT( BSON( "x" << "b" ).woCompare( BSON( "x" << "a" ) ) > 0 ); ASSERT( BSON( "x" << "a" << "y" << "a" ).woCompare( BSON( "x" << "a" << "y" << "b" ) ) < 0 ); ASSERT( BSON( "x" << "a" << "y" << "a" ).woCompare( BSON( "x" << "b" << "y" << "a" ) ) < 0 ); ASSERT( BSON( "x" << "a" << "y" << "a" ).woCompare( BSON( "x" << "b" ) ) < 0 ); ASSERT( BSON( "x" << "c" ).woCompare( BSON( "x" << "b" << "y" << "h" ) ) > 0 ); ASSERT( BSON( "x" << "b" << "y" << "b" ).woCompare( BSON( "x" << "c" ) ) < 0 ); BSONObj key = BSON( "x" << 1 << "y" << 1 ); ASSERT( BSON( "x" << "c" ).woSortOrder( BSON( "x" << "b" << "y" << "h" ) , key ) > 0 ); ASSERT( BSON( "x" << "b" << "y" << "b" ).woCompare( BSON( "x" << "c" ) , key ) < 0 ); key = BSON( "" << 1 << "" << 1 ); ASSERT( BSON( "" << "c" ).woSortOrder( BSON( "" << "b" << "" << "h" ) , key ) > 0 ); ASSERT( BSON( "" << "b" << "" << "b" ).woCompare( BSON( "" << "c" ) , key ) < 0 ); { BSONObjBuilder b; b.append( "" , "c" ); b.appendNull( "" ); BSONObj o = b.obj(); keyTest(o); ASSERT( o.woSortOrder( BSON( "" << "b" << "" << "h" ) , key ) > 0 ); ASSERT( BSON( "" << "b" << "" << "h" ).woSortOrder( o , key ) < 0 ); } ASSERT( BSON( "" << "a" ).woCompare( BSON( "" << "a" << "" << "c" ) ) < 0 ); { BSONObjBuilder b; b.append( "" , "a" ); b.appendNull( "" ); ASSERT( b.obj().woCompare( BSON( "" << "a" << "" << "c" ) ) < 0 ); // SERVER-282 } } }; class TimestampTest : public Base { public: void run() { Client *c = currentClient.get(); if( c == 0 ) { Client::initThread("pretouchN"); c = &cc(); } writelock lk(""); // for initTimestamp BSONObjBuilder b; b.appendTimestamp( "a" ); BSONObj o = b.done(); o.toString(); ASSERT( o.valid() ); ASSERT_EQUALS( Timestamp, o.getField( "a" ).type() ); BSONObjIterator i( o ); ASSERT( i.moreWithEOO() ); ASSERT( i.more() ); BSONElement e = i.next(); ASSERT_EQUALS( Timestamp, e.type() ); ASSERT( i.moreWithEOO() ); ASSERT( ! i.more() ); e = i.next(); ASSERT( e.eoo() ); OpTime before = OpTime::now(); BSONElementManipulator( o.firstElement() ).initTimestamp(); OpTime after = OpTime::now(); OpTime test = OpTime( o.firstElement().date() ); ASSERT( before < test && test < after ); BSONElementManipulator( o.firstElement() ).initTimestamp(); test = OpTime( o.firstElement().date() ); ASSERT( before < test && test < after ); OpTime x(123,456); ASSERT_EQUALS( 528280977864LL , x.asLL() ); } }; class Nan : public Base { public: void run() { double inf = numeric_limits< double >::infinity(); double nan = numeric_limits< double >::quiet_NaN(); double nan2 = numeric_limits< double >::signaling_NaN(); ASSERT( BSON( "a" << inf ).woCompare( BSON( "a" << inf ) ) == 0 ); ASSERT( BSON( "a" << inf ).woCompare( BSON( "a" << 1 ) ) < 0 ); ASSERT( BSON( "a" << 1 ).woCompare( BSON( "a" << inf ) ) > 0 ); ASSERT( BSON( "a" << nan ).woCompare( BSON( "a" << nan ) ) == 0 ); ASSERT( BSON( "a" << nan ).woCompare( BSON( "a" << 1 ) ) < 0 ); ASSERT( BSON( "a" << 1 ).woCompare( BSON( "a" << nan ) ) > 0 ); ASSERT( BSON( "a" << nan2 ).woCompare( BSON( "a" << nan2 ) ) == 0 ); ASSERT( BSON( "a" << nan2 ).woCompare( BSON( "a" << 1 ) ) < 0 ); ASSERT( BSON( "a" << 1 ).woCompare( BSON( "a" << nan2 ) ) > 0 ); ASSERT( BSON( "a" << inf ).woCompare( BSON( "a" << nan ) ) == 0 ); ASSERT( BSON( "a" << inf ).woCompare( BSON( "a" << nan2 ) ) == 0 ); ASSERT( BSON( "a" << nan ).woCompare( BSON( "a" << nan2 ) ) == 0 ); } }; class AsTempObj { public: void run() { { BSONObjBuilder bb; bb << "a" << 1; BSONObj tmp = bb.asTempObj(); ASSERT(tmp.objsize() == 4+(1+2+4)+1); ASSERT(tmp.valid()); ASSERT(tmp.hasField("a")); ASSERT(!tmp.hasField("b")); ASSERT(tmp == BSON("a" << 1)); bb << "b" << 2; BSONObj obj = bb.obj(); ASSERT_EQUALS(obj.objsize() , 4+(1+2+4)+(1+2+4)+1); ASSERT(obj.valid()); ASSERT(obj.hasField("a")); ASSERT(obj.hasField("b")); ASSERT(obj == BSON("a" << 1 << "b" << 2)); } { BSONObjBuilder bb; bb << "a" << GT << 1; BSONObj tmp = bb.asTempObj(); ASSERT(tmp.objsize() == 4+(1+2+(4+1+4+4+1))+1); ASSERT(tmp.valid()); ASSERT(tmp.hasField("a")); ASSERT(!tmp.hasField("b")); ASSERT(tmp == BSON("a" << BSON("$gt" << 1))); bb << "b" << LT << 2; BSONObj obj = bb.obj(); ASSERT(obj.objsize() == 4+(1+2+(4+1+4+4+1))+(1+2+(4+1+4+4+1))+1); ASSERT(obj.valid()); ASSERT(obj.hasField("a")); ASSERT(obj.hasField("b")); ASSERT(obj == BSON("a" << BSON("$gt" << 1) << "b" << BSON("$lt" << 2))); } { BSONObjBuilder bb(32); bb << "a" << 1; BSONObj tmp = bb.asTempObj(); ASSERT(tmp.objsize() == 4+(1+2+4)+1); ASSERT(tmp.valid()); ASSERT(tmp.hasField("a")); ASSERT(!tmp.hasField("b")); ASSERT(tmp == BSON("a" << 1)); //force a realloc BSONArrayBuilder arr; for (int i=0; i < 10000; i++) { arr << i; } bb << "b" << arr.arr(); BSONObj obj = bb.obj(); ASSERT(obj.valid()); ASSERT(obj.hasField("a")); ASSERT(obj.hasField("b")); } } }; struct AppendIntOrLL { void run() { const long long billion = 1000*1000*1000; { BSONObjBuilder b; b.appendIntOrLL("L4", -4*billion); keyTest(b.obj()); keyTest( BSON("" << billion) ); } BSONObjBuilder b; b.appendIntOrLL("i1", 1); b.appendIntOrLL("i2", -1); b.appendIntOrLL("i3", 1*billion); b.appendIntOrLL("i4", -1*billion); b.appendIntOrLL("L1", 2*billion); b.appendIntOrLL("L2", -2*billion); b.appendIntOrLL("L3", 4*billion); b.appendIntOrLL("L4", -4*billion); b.appendIntOrLL("L5", 16*billion); b.appendIntOrLL("L6", -16*billion); BSONObj o = b.obj(); keyTest(o); ASSERT(o["i1"].type() == NumberInt); ASSERT(o["i1"].number() == 1); ASSERT(o["i2"].type() == NumberInt); ASSERT(o["i2"].number() == -1); ASSERT(o["i3"].type() == NumberInt); ASSERT(o["i3"].number() == 1*billion); ASSERT(o["i4"].type() == NumberInt); ASSERT(o["i4"].number() == -1*billion); ASSERT(o["L1"].type() == NumberLong); ASSERT(o["L1"].number() == 2*billion); ASSERT(o["L2"].type() == NumberLong); ASSERT(o["L2"].number() == -2*billion); ASSERT(o["L3"].type() == NumberLong); ASSERT(o["L3"].number() == 4*billion); ASSERT(o["L4"].type() == NumberLong); ASSERT(o["L4"].number() == -4*billion); ASSERT(o["L5"].type() == NumberLong); ASSERT(o["L5"].number() == 16*billion); ASSERT(o["L6"].type() == NumberLong); ASSERT(o["L6"].number() == -16*billion); } }; struct AppendNumber { void run() { BSONObjBuilder b; b.appendNumber( "a" , 5 ); b.appendNumber( "b" , 5.5 ); b.appendNumber( "c" , (1024LL*1024*1024)-1 ); b.appendNumber( "d" , (1024LL*1024*1024*1024)-1 ); b.appendNumber( "e" , 1024LL*1024*1024*1024*1024*1024 ); BSONObj o = b.obj(); keyTest(o); ASSERT( o["a"].type() == NumberInt ); ASSERT( o["b"].type() == NumberDouble ); ASSERT( o["c"].type() == NumberInt ); ASSERT( o["d"].type() == NumberDouble ); ASSERT( o["e"].type() == NumberLong ); } }; class ToStringArray { public: void run() { string spec = "{ a: [ \"a\", \"b\" ] }"; ASSERT_EQUALS( spec, fromjson( spec ).toString() ); BSONObj x = BSON( "a" << "astring" << "b" << "str" ); keyTest(x); keyTest(x); BSONObj y = BSON( "a" << "astring" << "b" << "stra" ); keyTest(y); y = BSON( "a" << "" ); keyTest(y); keyTest( BSON("abc" << true ) ); keyTest( BSON("abc" << false ) ); keyTest( BSON("abc" << false << "b" << true ) ); Date_t now = jsTime(); keyTest( BSON("" << now << "" << 3 << "" << jstNULL << "" << true) ); keyTest( BSON("" << now << "" << 3 << "" << BSONObj() << "" << true) ); { { // check signed dates with new key format KeyV1Owned a( BSONObjBuilder().appendDate("", -50).obj() ); KeyV1Owned b( BSONObjBuilder().appendDate("", 50).obj() ); ASSERT( a.woCompare(b, Ordering::make(BSONObj())) < 0 ); } { // backward compatibility KeyBson a( BSONObjBuilder().appendDate("", -50).obj() ); KeyBson b( BSONObjBuilder().appendDate("", 50).obj() ); ASSERT( a.woCompare(b, Ordering::make(BSONObj())) > 0 ); } { // this is an uncompactible key: BSONObj uc1 = BSONObjBuilder().appendDate("", -50).appendCode("", "abc").obj(); BSONObj uc2 = BSONObjBuilder().appendDate("", 55).appendCode("", "abc").obj(); ASSERT( uc1.woCompare(uc2, Ordering::make(BSONObj())) < 0 ); { KeyV1Owned a(uc1); KeyV1Owned b(uc2); ASSERT( !a.isCompactFormat() ); ASSERT( a.woCompare(b, Ordering::make(BSONObj())) < 0 ); } { KeyBson a(uc1); KeyBson b(uc2); ASSERT( !a.isCompactFormat() ); ASSERT( a.woCompare(b, Ordering::make(BSONObj())) > 0 ); } } } { BSONObjBuilder b; b.appendBinData("f", 8, (BinDataType) 1, "aaaabbbb"); b.appendBinData("e", 3, (BinDataType) 1, "aaa"); b.appendBinData("b", 1, (BinDataType) 1, "x"); BSONObj o = b.obj(); keyTest( o, true ); } { for( int i = 1; i <= 3; i++ ) { for( int j = 1; j <= 3; j++ ) { BSONObjBuilder b; b.appendBinData("f", i, (BinDataType) j, "abc"); BSONObj o = b.obj(); keyTest( o, j != ByteArrayDeprecated ); } } } { BSONObjBuilder b; b.appendBinData("f", 1, (BinDataType) 133, "a"); BSONObj o = b.obj(); keyTest( o, true ); } { BSONObjBuilder b; b.append("AA", 3); b.appendBinData("f", 0, (BinDataType) 0, ""); b.appendBinData("e", 3, (BinDataType) 7, "aaa"); b.appendBinData("b", 1, (BinDataType) 128, "x"); b.append("z", 3); b.appendBinData("bb", 0, (BinDataType) 129, "x"); BSONObj o = b.obj(); keyTest( o, true ); } { // 9 is not supported in compact format. so test a non-compact case here. BSONObjBuilder b; b.appendBinData("f", 9, (BinDataType) 0, "aaaabbbbc"); BSONObj o = b.obj(); keyTest( o ); } } }; class ToStringNumber { public: void run() { BSONObjBuilder b; b.append( "a" , (int)4 ); b.append( "b" , (double)5 ); b.append( "c" , (long long)6 ); b.append( "d" , 123.456789123456789123456789123456789 ); b.append( "e" , 123456789.123456789123456789123456789 ); b.append( "f" , 1234567891234567891234.56789123456789 ); b.append( "g" , -123.456 ); BSONObj x = b.obj(); keyTest(x); ASSERT_EQUALS( "4", x["a"].toString( false , true ) ); ASSERT_EQUALS( "5.0", x["b"].toString( false , true ) ); ASSERT_EQUALS( "6", x["c"].toString( false , true ) ); ASSERT_EQUALS( "123.4567891234568" , x["d"].toString( false , true ) ); ASSERT_EQUALS( "123456789.1234568" , x["e"].toString( false , true ) ); // ASSERT_EQUALS( "1.234567891234568e+21" , x["f"].toString( false , true ) ); // windows and *nix are different - TODO, work around for test or not bother? ASSERT_EQUALS( "-123.456" , x["g"].toString( false , true ) ); } }; class NullString { public: void run() { { BSONObjBuilder b; const char x[] = {'a', 0, 'b', 0}; b.append("field", x, 4); b.append("z", true); BSONObj B = b.obj(); //cout << B.toString() << endl; BSONObjBuilder a; const char xx[] = {'a', 0, 'c', 0}; a.append("field", xx, 4); a.append("z", true); BSONObj A = a.obj(); BSONObjBuilder c; const char xxx[] = {'a', 0, 'c', 0, 0}; c.append("field", xxx, 5); c.append("z", true); BSONObj C = c.obj(); // test that nulls are ok within bson strings ASSERT( !(A == B) ); ASSERT( A > B ); ASSERT( !(B == C) ); ASSERT( C > B ); // check iteration is ok ASSERT( B["z"].Bool() && A["z"].Bool() && C["z"].Bool() ); } BSONObjBuilder b; b.append("a", "a\0b", 4); string z("a\0b", 3); b.append("b", z); b.appendAs(b.asTempObj()["a"], "c"); BSONObj o = b.obj(); keyTest(o); stringstream ss; ss << 'a' << '\0' << 'b'; ASSERT_EQUALS(o["a"].valuestrsize(), 3+1); ASSERT_EQUALS(o["a"].str(), ss.str()); ASSERT_EQUALS(o["b"].valuestrsize(), 3+1); ASSERT_EQUALS(o["b"].str(), ss.str()); ASSERT_EQUALS(o["c"].valuestrsize(), 3+1); ASSERT_EQUALS(o["c"].str(), ss.str()); } }; class AppendAs { public: void run() { BSONObjBuilder b; { BSONObj foo = BSON( "foo" << 1 ); b.appendAs( foo.firstElement(), "bar" ); } ASSERT_EQUALS( BSON( "bar" << 1 ), b.done() ); } }; class ArrayAppendAs { public: void run() { BSONArrayBuilder b; { BSONObj foo = BSON( "foo" << 1 ); b.appendAs( foo.firstElement(), "3" ); } BSONArray a = b.arr(); BSONObj expected = BSON( "3" << 1 ); ASSERT_EQUALS( expected.firstElement(), a[ 3 ] ); ASSERT_EQUALS( 4, a.nFields() ); } }; class GetField { public: void run(){ BSONObj o = BSON( "a" << 1 << "b" << BSON( "a" << 2 ) << "c" << BSON_ARRAY( BSON( "a" << 3 ) << BSON( "a" << 4 ) ) ); ASSERT_EQUALS( 1 , o.getFieldDotted( "a" ).numberInt() ); ASSERT_EQUALS( 2 , o.getFieldDotted( "b.a" ).numberInt() ); ASSERT_EQUALS( 3 , o.getFieldDotted( "c.0.a" ).numberInt() ); ASSERT_EQUALS( 4 , o.getFieldDotted( "c.1.a" ).numberInt() ); keyTest(o); } }; namespace Validation { class Base { public: virtual ~Base() {} void run() { ASSERT( valid().valid() ); ASSERT( !invalid().valid() ); } protected: virtual BSONObj valid() const { return BSONObj(); } virtual BSONObj invalid() const { return BSONObj(); } static char get( const BSONObj &o, int i ) { return o.objdata()[ i ]; } static void set( BSONObj &o, int i, char c ) { const_cast< char * >( o.objdata() )[ i ] = c; } }; class BadType : public Base { BSONObj valid() const { return fromjson( "{\"a\":1}" ); } BSONObj invalid() const { BSONObj ret = valid(); set( ret, 4, 50 ); return ret; } }; class EooBeforeEnd : public Base { BSONObj valid() const { return fromjson( "{\"a\":1}" ); } BSONObj invalid() const { BSONObj ret = valid(); // (first byte of size)++ set( ret, 0, get( ret, 0 ) + 1 ); // re-read size for BSONObj::details return ret.copy(); } }; class Undefined : public Base { public: void run() { BSONObjBuilder b; b.appendNull( "a" ); BSONObj o = b.done(); set( o, 4, mongo::Undefined ); ASSERT( o.valid() ); } }; class TotalSizeTooSmall : public Base { BSONObj valid() const { return fromjson( "{\"a\":1}" ); } BSONObj invalid() const { BSONObj ret = valid(); // (first byte of size)-- set( ret, 0, get( ret, 0 ) - 1 ); // re-read size for BSONObj::details return ret.copy(); } }; class EooMissing : public Base { BSONObj valid() const { return fromjson( "{\"a\":1}" ); } BSONObj invalid() const { BSONObj ret = valid(); set( ret, ret.objsize() - 1, (char) 0xff ); // (first byte of size)-- set( ret, 0, get( ret, 0 ) - 1 ); // re-read size for BSONObj::details return ret.copy(); } }; class WrongStringSize : public Base { BSONObj valid() const { return fromjson( "{\"a\":\"b\"}" ); } BSONObj invalid() const { BSONObj ret = valid(); ASSERT_EQUALS( ret.firstElement().valuestr()[0] , 'b' ); ASSERT_EQUALS( ret.firstElement().valuestr()[1] , 0 ); ((char*)ret.firstElement().valuestr())[1] = 1; return ret.copy(); } }; class ZeroStringSize : public Base { BSONObj valid() const { return fromjson( "{\"a\":\"b\"}" ); } BSONObj invalid() const { BSONObj ret = valid(); set( ret, 7, 0 ); return ret; } }; class NegativeStringSize : public Base { BSONObj valid() const { return fromjson( "{\"a\":\"b\"}" ); } BSONObj invalid() const { BSONObj ret = valid(); set( ret, 10, -100 ); return ret; } }; class WrongSubobjectSize : public Base { BSONObj valid() const { return fromjson( "{\"a\":{\"b\":1}}" ); } BSONObj invalid() const { BSONObj ret = valid(); set( ret, 0, get( ret, 0 ) + 1 ); set( ret, 7, get( ret, 7 ) + 1 ); return ret.copy(); } }; class WrongDbrefNsSize : public Base { BSONObj valid() const { return fromjson( "{ \"a\": Dbref( \"b\", \"ffffffffffffffffffffffff\" ) }" ); } BSONObj invalid() const { BSONObj ret = valid(); set( ret, 0, get( ret, 0 ) + 1 ); set( ret, 7, get( ret, 7 ) + 1 ); return ret.copy(); }; }; class NoFieldNameEnd : public Base { BSONObj valid() const { return fromjson( "{\"a\":1}" ); } BSONObj invalid() const { BSONObj ret = valid(); memset( const_cast< char * >( ret.objdata() ) + 5, 0xff, ret.objsize() - 5 ); return ret; } }; class BadRegex : public Base { BSONObj valid() const { return fromjson( "{\"a\":/c/i}" ); } BSONObj invalid() const { BSONObj ret = valid(); memset( const_cast< char * >( ret.objdata() ) + 7, 0xff, ret.objsize() - 7 ); return ret; } }; class BadRegexOptions : public Base { BSONObj valid() const { return fromjson( "{\"a\":/c/i}" ); } BSONObj invalid() const { BSONObj ret = valid(); memset( const_cast< char * >( ret.objdata() ) + 9, 0xff, ret.objsize() - 9 ); return ret; } }; class CodeWScopeBase : public Base { BSONObj valid() const { BSONObjBuilder b; BSONObjBuilder scope; scope.append( "a", "b" ); b.appendCodeWScope( "c", "d", scope.done() ); return b.obj(); } BSONObj invalid() const { BSONObj ret = valid(); modify( ret ); return ret; } protected: virtual void modify( BSONObj &o ) const = 0; }; class CodeWScopeSmallSize : public CodeWScopeBase { void modify( BSONObj &o ) const { set( o, 7, 7 ); } }; class CodeWScopeZeroStrSize : public CodeWScopeBase { void modify( BSONObj &o ) const { set( o, 11, 0 ); } }; class CodeWScopeSmallStrSize : public CodeWScopeBase { void modify( BSONObj &o ) const { set( o, 11, 1 ); } }; class CodeWScopeNoSizeForObj : public CodeWScopeBase { void modify( BSONObj &o ) const { set( o, 7, 13 ); } }; class CodeWScopeSmallObjSize : public CodeWScopeBase { void modify( BSONObj &o ) const { set( o, 17, 1 ); } }; class CodeWScopeBadObject : public CodeWScopeBase { void modify( BSONObj &o ) const { set( o, 21, JSTypeMax + 1 ); } }; class NoSize { public: NoSize( BSONType type ) : type_( type ) {} void run() { const char data[] = { 0x07, 0x00, 0x00, 0x00, char( type_ ), 'a', 0x00 }; BSONObj o( data ); ASSERT( !o.valid() ); } private: BSONType type_; }; // Randomized BSON parsing test. See if we seg fault. class Fuzz { public: Fuzz( double frequency ) : frequency_( frequency ) {} void run() { BSONObj a = fromjson( "{\"a\": 1, \"b\": \"c\"}" ); fuzz( a ); a.valid(); BSONObj b = fromjson( "{\"one\":2, \"two\":5, \"three\": {}," "\"four\": { \"five\": { \"six\" : 11 } }," "\"seven\": [ \"a\", \"bb\", \"ccc\", 5 ]," "\"eight\": Dbref( \"rrr\", \"01234567890123456789aaaa\" )," "\"_id\": ObjectId( \"deadbeefdeadbeefdeadbeef\" )," "\"nine\": { \"$binary\": \"abc=\", \"$type\": \"00\" }," "\"ten\": Date( 44 ), \"eleven\": /foooooo/i }" ); fuzz( b ); b.valid(); } private: void fuzz( BSONObj &o ) const { for( int i = 4; i < o.objsize(); ++i ) for( unsigned char j = 1; j; j <<= 1 ) if ( rand() < int( RAND_MAX * frequency_ ) ) { char *c = const_cast< char * >( o.objdata() ) + i; if ( *c & j ) *c &= ~j; else *c |= j; } } double frequency_; }; } // namespace Validation } // namespace BSONObjTests namespace OIDTests { class init1 { public: void run() { OID a; OID b; a.init(); b.init(); ASSERT( a != b ); } }; class initParse1 { public: void run() { OID a; OID b; a.init(); b.init( a.str() ); ASSERT( a == b ); } }; class append { public: void run() { BSONObjBuilder b; b.appendOID( "a" , 0 ); b.appendOID( "b" , 0 , false ); b.appendOID( "c" , 0 , true ); BSONObj o = b.obj(); keyTest(o); ASSERT( o["a"].__oid().str() == "000000000000000000000000" ); ASSERT( o["b"].__oid().str() == "000000000000000000000000" ); ASSERT( o["c"].__oid().str() != "000000000000000000000000" ); } }; class increasing { public: BSONObj g() { BSONObjBuilder b; b.appendOID( "_id" , 0 , true ); return b.obj(); } void run() { BSONObj a = g(); BSONObj b = g(); ASSERT( a.woCompare( b ) < 0 ); // yes, there is a 1/1000 chance this won't increase time(0) // and therefore inaccurately say the function is behaving // buf if its broken, it will fail 999/1000, so i think that's good enough sleepsecs( 1 ); BSONObj c = g(); ASSERT( a.woCompare( c ) < 0 ); } }; class ToDate { public: void run() { OID oid; { time_t before = ::time(0); oid.init(); time_t after = ::time(0); ASSERT( oid.asTimeT() >= before ); ASSERT( oid.asTimeT() <= after ); } { Date_t before = jsTime(); sleepsecs(1); oid.init(); Date_t after = jsTime(); ASSERT( oid.asDateT() >= before ); ASSERT( oid.asDateT() <= after ); } } }; class FromDate { public: void run() { OID min, oid, max; Date_t now = jsTime(); oid.init(); // slight chance this has different time. If its a problem, can change. min.init(now); max.init(now, true); ASSERT_EQUALS( (unsigned)oid.asTimeT() , now/1000 ); ASSERT_EQUALS( (unsigned)min.asTimeT() , now/1000 ); ASSERT_EQUALS( (unsigned)max.asTimeT() , now/1000 ); ASSERT( BSON("" << min).woCompare( BSON("" << oid) ) < 0 ); ASSERT( BSON("" << max).woCompare( BSON("" << oid) )> 0 ); } }; } // namespace OIDTests namespace ValueStreamTests { class LabelBase { public: virtual ~LabelBase() {} void run() { ASSERT( !expected().woCompare( actual() ) ); } protected: virtual BSONObj expected() = 0; virtual BSONObj actual() = 0; }; class LabelBasic : public LabelBase { BSONObj expected() { return BSON( "a" << ( BSON( "$gt" << 1 ) ) ); } BSONObj actual() { return BSON( "a" << GT << 1 ); } }; class LabelShares : public LabelBase { BSONObj expected() { return BSON( "z" << "q" << "a" << ( BSON( "$gt" << 1 ) ) << "x" << "p" ); } BSONObj actual() { return BSON( "z" << "q" << "a" << GT << 1 << "x" << "p" ); } }; class LabelDouble : public LabelBase { BSONObj expected() { return BSON( "a" << ( BSON( "$gt" << 1 << "$lte" << "x" ) ) ); } BSONObj actual() { return BSON( "a" << GT << 1 << LTE << "x" ); } }; class LabelDoubleShares : public LabelBase { BSONObj expected() { return BSON( "z" << "q" << "a" << ( BSON( "$gt" << 1 << "$lte" << "x" ) ) << "x" << "p" ); } BSONObj actual() { return BSON( "z" << "q" << "a" << GT << 1 << LTE << "x" << "x" << "p" ); } }; class LabelSize : public LabelBase { BSONObj expected() { return BSON( "a" << BSON( "$size" << 4 ) ); } BSONObj actual() { return BSON( "a" << mongo::SIZE << 4 ); } }; class LabelMulti : public LabelBase { BSONObj expected() { return BSON( "z" << "q" << "a" << BSON( "$gt" << 1 << "$lte" << "x" ) << "b" << BSON( "$ne" << 1 << "$ne" << "f" << "$ne" << 22.3 ) << "x" << "p" ); } BSONObj actual() { return BSON( "z" << "q" << "a" << GT << 1 << LTE << "x" << "b" << NE << 1 << NE << "f" << NE << 22.3 << "x" << "p" ); } }; class LabelishOr : public LabelBase { BSONObj expected() { return BSON( "$or" << BSON_ARRAY( BSON("a" << BSON( "$gt" << 1 << "$lte" << "x" )) << BSON("b" << BSON( "$ne" << 1 << "$ne" << "f" << "$ne" << 22.3 )) << BSON("x" << "p" ))); } BSONObj actual() { return OR( BSON( "a" << GT << 1 << LTE << "x"), BSON( "b" << NE << 1 << NE << "f" << NE << 22.3), BSON( "x" << "p" ) ); } }; class Unallowed { public: void run() { ASSERT_EXCEPTION( BSON( GT << 4 ), MsgAssertionException ); ASSERT_EXCEPTION( BSON( "a" << 1 << GT << 4 ), MsgAssertionException ); } }; class ElementAppend { public: void run() { BSONObj a = BSON( "a" << 17 ); BSONObj b = BSON( "b" << a["a"] ); ASSERT_EQUALS( NumberInt , a["a"].type() ); ASSERT_EQUALS( NumberInt , b["b"].type() ); ASSERT_EQUALS( 17 , b["b"].number() ); } }; } // namespace ValueStreamTests class SubObjectBuilder { public: void run() { BSONObjBuilder b1; b1.append( "a", "bcd" ); BSONObjBuilder b2( b1.subobjStart( "foo" ) ); b2.append( "ggg", 44.0 ); b2.done(); b1.append( "f", 10.0 ); BSONObj ret = b1.done(); ASSERT( ret.valid() ); ASSERT( ret.woCompare( fromjson( "{a:'bcd',foo:{ggg:44},f:10}" ) ) == 0 ); } }; class DateBuilder { public: void run() { BSONObj o = BSON("" << Date_t(1234567890)); ASSERT( o.firstElement().type() == Date ); ASSERT( o.firstElement().date() == Date_t(1234567890) ); } }; class DateNowBuilder { public: void run() { Date_t before = jsTime(); BSONObj o = BSON("now" << DATENOW); Date_t after = jsTime(); ASSERT( o.valid() ); BSONElement e = o["now"]; ASSERT( e.type() == Date ); ASSERT( e.date() >= before ); ASSERT( e.date() <= after ); } }; class TimeTBuilder { public: void run() { Date_t before = jsTime(); sleepmillis(1); time_t now = time(NULL); sleepmillis(1); Date_t after = jsTime(); BSONObjBuilder b; b.appendTimeT("now", now); BSONObj o = b.obj(); ASSERT( o.valid() ); BSONElement e = o["now"]; ASSERT( e.type() == Date ); ASSERT( e.date()/1000 >= before/1000 ); ASSERT( e.date()/1000 <= after/1000 ); } }; class MinMaxKeyBuilder { public: void run() { BSONObj min = BSON( "a" << MINKEY ); BSONObj max = BSON( "b" << MAXKEY ); ASSERT( min.valid() ); ASSERT( max.valid() ); BSONElement minElement = min["a"]; BSONElement maxElement = max["b"]; ASSERT( minElement.type() == MinKey ); ASSERT( maxElement.type() == MaxKey ); } }; class MinMaxElementTest { public: BSONObj min( int t ) { BSONObjBuilder b; b.appendMinForType( "a" , t ); return b.obj(); } BSONObj max( int t ) { BSONObjBuilder b; b.appendMaxForType( "a" , t ); return b.obj(); } void run() { for ( int t=1; t 0 ); massert( 10405 , s , min( t ).woCompare( min( t ) ) == 0 ); massert( 10406 , s , max( t ).woCompare( max( t ) ) == 0 ); massert( 10407 , s , abs( min( t ).firstElement().canonicalType() - max( t ).firstElement().canonicalType() ) <= 10 ); } } }; class ExtractFieldsTest { public: void run() { BSONObj x = BSON( "a" << 10 << "b" << 11 ); assert( BSON( "a" << 10 ).woCompare( x.extractFields( BSON( "a" << 1 ) ) ) == 0 ); assert( BSON( "b" << 11 ).woCompare( x.extractFields( BSON( "b" << 1 ) ) ) == 0 ); assert( x.woCompare( x.extractFields( BSON( "a" << 1 << "b" << 1 ) ) ) == 0 ); assert( (string)"a" == x.extractFields( BSON( "a" << 1 << "c" << 1 ) ).firstElementFieldName() ); } }; class ComparatorTest { public: BSONObj one( string s ) { return BSON( "x" << s ); } BSONObj two( string x , string y ) { BSONObjBuilder b; b.append( "x" , x ); if ( y.size() ) b.append( "y" , y ); else b.appendNull( "y" ); return b.obj(); } void test( BSONObj order , BSONObj l , BSONObj r , bool wanted ) { BSONObjCmp c( order ); bool got = c(l,r); if ( got == wanted ) return; cout << " order: " << order << " l: " << l << "r: " << r << " wanted: " << wanted << " got: " << got << endl; } void lt( BSONObj order , BSONObj l , BSONObj r ) { test( order , l , r , 1 ); } void run() { BSONObj s = BSON( "x" << 1 ); BSONObj c = BSON( "x" << 1 << "y" << 1 ); test( s , one( "A" ) , one( "B" ) , 1 ); test( s , one( "B" ) , one( "A" ) , 0 ); test( c , two( "A" , "A" ) , two( "A" , "B" ) , 1 ); test( c , two( "A" , "A" ) , two( "B" , "A" ) , 1 ); test( c , two( "B" , "A" ) , two( "A" , "B" ) , 0 ); lt( c , one("A") , two( "A" , "A" ) ); lt( c , one("A") , one( "B" ) ); lt( c , two("A","") , two( "B" , "A" ) ); lt( c , two("B","A") , two( "C" , "A" ) ); lt( c , two("B","A") , one( "C" ) ); lt( c , two("B","A") , two( "C" , "" ) ); } }; namespace external_sort { class Basic1 { public: void run() { BSONObjExternalSorter sorter; sorter.add( BSON( "x" << 10 ) , 5 , 1); sorter.add( BSON( "x" << 2 ) , 3 , 1 ); sorter.add( BSON( "x" << 5 ) , 6 , 1 ); sorter.add( BSON( "x" << 5 ) , 7 , 1 ); sorter.sort(); auto_ptr i = sorter.iterator(); int num=0; while ( i->more() ) { pair p = i->next(); if ( num == 0 ) assert( p.first["x"].number() == 2 ); else if ( num <= 2 ) { assert( p.first["x"].number() == 5 ); } else if ( num == 3 ) assert( p.first["x"].number() == 10 ); else ASSERT( 0 ); num++; } ASSERT_EQUALS( 0 , sorter.numFiles() ); } }; class Basic2 { public: void run() { BSONObjExternalSorter sorter( BSONObj() , 10 ); sorter.add( BSON( "x" << 10 ) , 5 , 11 ); sorter.add( BSON( "x" << 2 ) , 3 , 1 ); sorter.add( BSON( "x" << 5 ) , 6 , 1 ); sorter.add( BSON( "x" << 5 ) , 7 , 1 ); sorter.sort(); auto_ptr i = sorter.iterator(); int num=0; while ( i->more() ) { pair p = i->next(); if ( num == 0 ) { assert( p.first["x"].number() == 2 ); ASSERT_EQUALS( p.second.toString() , "3:1" ); } else if ( num <= 2 ) assert( p.first["x"].number() == 5 ); else if ( num == 3 ) { assert( p.first["x"].number() == 10 ); ASSERT_EQUALS( p.second.toString() , "5:b" ); } else ASSERT( 0 ); num++; } } }; class Basic3 { public: void run() { BSONObjExternalSorter sorter( BSONObj() , 10 ); sorter.sort(); auto_ptr i = sorter.iterator(); assert( ! i->more() ); } }; class ByDiskLock { public: void run() { BSONObjExternalSorter sorter; sorter.add( BSON( "x" << 10 ) , 5 , 4); sorter.add( BSON( "x" << 2 ) , 3 , 0 ); sorter.add( BSON( "x" << 5 ) , 6 , 2 ); sorter.add( BSON( "x" << 5 ) , 7 , 3 ); sorter.add( BSON( "x" << 5 ) , 2 , 1 ); sorter.sort(); auto_ptr i = sorter.iterator(); int num=0; while ( i->more() ) { pair p = i->next(); if ( num == 0 ) assert( p.first["x"].number() == 2 ); else if ( num <= 3 ) { assert( p.first["x"].number() == 5 ); } else if ( num == 4 ) assert( p.first["x"].number() == 10 ); else ASSERT( 0 ); ASSERT_EQUALS( num , p.second.getOfs() ); num++; } } }; class Big1 { public: void run() { BSONObjExternalSorter sorter( BSONObj() , 2000 ); for ( int i=0; i<10000; i++ ) { sorter.add( BSON( "x" << rand() % 10000 ) , 5 , i ); } sorter.sort(); auto_ptr i = sorter.iterator(); int num=0; double prev = 0; while ( i->more() ) { pair p = i->next(); num++; double cur = p.first["x"].number(); assert( cur >= prev ); prev = cur; } assert( num == 10000 ); } }; class Big2 { public: void run() { const int total = 100000; BSONObjExternalSorter sorter( BSONObj() , total * 2 ); for ( int i=0; i i = sorter.iterator(); int num=0; double prev = 0; while ( i->more() ) { pair p = i->next(); num++; double cur = p.first["x"].number(); assert( cur >= prev ); prev = cur; } assert( num == total ); ASSERT( sorter.numFiles() > 2 ); } }; class D1 { public: void run() { BSONObjBuilder b; b.appendNull(""); BSONObj x = b.obj(); BSONObjExternalSorter sorter; sorter.add(x, DiskLoc(3,7)); sorter.add(x, DiskLoc(4,7)); sorter.add(x, DiskLoc(2,7)); sorter.add(x, DiskLoc(1,7)); sorter.add(x, DiskLoc(3,77)); sorter.sort(); auto_ptr i = sorter.iterator(); while( i->more() ) { BSONObjExternalSorter::Data d = i->next(); /*cout << d.second.toString() << endl; cout << d.first.objsize() << endl; cout<<"SORTER next:" << d.first.toString() << endl;*/ } } }; } class CompatBSON { public: #define JSONBSONTEST(j,s,m) ASSERT_EQUALS( fromjson( j ).objsize() , s ); ASSERT_EQUALS( fromjson( j ).md5() , m ); #define RAWBSONTEST(j,s,m) ASSERT_EQUALS( j.objsize() , s ); ASSERT_EQUALS( j.md5() , m ); void run() { JSONBSONTEST( "{ 'x' : true }" , 9 , "6fe24623e4efc5cf07f027f9c66b5456" ); JSONBSONTEST( "{ 'x' : null }" , 8 , "12d43430ff6729af501faf0638e68888" ); JSONBSONTEST( "{ 'x' : 5.2 }" , 16 , "aaeeac4a58e9c30eec6b0b0319d0dff2" ); JSONBSONTEST( "{ 'x' : 'eliot' }" , 18 , "331a3b8b7cbbe0706c80acdb45d4ebbe" ); JSONBSONTEST( "{ 'x' : 5.2 , 'y' : 'truth' , 'z' : 1.1 }" , 40 , "7c77b3a6e63e2f988ede92624409da58" ); JSONBSONTEST( "{ 'a' : { 'b' : 1.1 } }" , 24 , "31887a4b9d55cd9f17752d6a8a45d51f" ); JSONBSONTEST( "{ 'x' : 5.2 , 'y' : { 'a' : 'eliot' , b : true } , 'z' : null }" , 44 , "b3de8a0739ab329e7aea138d87235205" ); JSONBSONTEST( "{ 'x' : 5.2 , 'y' : [ 'a' , 'eliot' , 'b' , true ] , 'z' : null }" , 62 , "cb7bad5697714ba0cbf51d113b6a0ee8" ); RAWBSONTEST( BSON( "x" << 4 ) , 12 , "d1ed8dbf79b78fa215e2ded74548d89d" ); } }; class CompareDottedFieldNamesTest { public: void t( FieldCompareResult res , const string& l , const string& r ) { ASSERT_EQUALS( res , compareDottedFieldNames( l , r ) ); ASSERT_EQUALS( -1 * res , compareDottedFieldNames( r , l ) ); } void run() { t( SAME , "x" , "x" ); t( SAME , "x.a" , "x.a" ); t( LEFT_BEFORE , "a" , "b" ); t( RIGHT_BEFORE , "b" , "a" ); t( LEFT_SUBFIELD , "a.x" , "a" ); } }; struct NestedDottedConversions { void t(const BSONObj& nest, const BSONObj& dot) { ASSERT_EQUALS( nested2dotted(nest), dot); ASSERT_EQUALS( nest, dotted2nested(dot)); } void run() { t( BSON("a" << BSON("b" << 1)), BSON("a.b" << 1) ); t( BSON("a" << BSON("b" << 1 << "c" << 1)), BSON("a.b" << 1 << "a.c" << 1) ); t( BSON("a" << BSON("b" << 1 << "c" << 1) << "d" << 1), BSON("a.b" << 1 << "a.c" << 1 << "d" << 1) ); t( BSON("a" << BSON("b" << 1 << "c" << 1 << "e" << BSON("f" << 1)) << "d" << 1), BSON("a.b" << 1 << "a.c" << 1 << "a.e.f" << 1 << "d" << 1) ); } }; struct BSONArrayBuilderTest { void run() { int i = 0; BSONObjBuilder objb; BSONArrayBuilder arrb; objb << objb.numStr(i++) << 100; arrb << 100; objb << objb.numStr(i++) << 1.0; arrb << 1.0; objb << objb.numStr(i++) << "Hello"; arrb << "Hello"; objb << objb.numStr(i++) << string("World"); arrb << string("World"); objb << objb.numStr(i++) << BSON( "a" << 1 << "b" << "foo" ); arrb << BSON( "a" << 1 << "b" << "foo" ); objb << objb.numStr(i++) << BSON( "a" << 1)["a"]; arrb << BSON( "a" << 1)["a"]; OID oid; oid.init(); objb << objb.numStr(i++) << oid; arrb << oid; BSONObj obj = objb.obj(); BSONArray arr = arrb.arr(); ASSERT_EQUALS(obj, arr); BSONObj o = BSON( "obj" << obj << "arr" << arr << "arr2" << BSONArray(obj) ); keyTest(o); ASSERT_EQUALS(o["obj"].type(), Object); ASSERT_EQUALS(o["arr"].type(), Array); ASSERT_EQUALS(o["arr2"].type(), Array); } }; struct ArrayMacroTest { void run() { BSONArray arr = BSON_ARRAY( "hello" << 1 << BSON( "foo" << BSON_ARRAY( "bar" << "baz" << "qux" ) ) ); BSONObj obj = BSON( "0" << "hello" << "1" << 1 << "2" << BSON( "foo" << BSON_ARRAY( "bar" << "baz" << "qux" ) ) ); ASSERT_EQUALS(arr, obj); ASSERT_EQUALS(arr["2"].type(), Object); ASSERT_EQUALS(arr["2"].embeddedObject()["foo"].type(), Array); } }; class NumberParsing { public: void run() { BSONObjBuilder a; BSONObjBuilder b; a.append( "a" , (int)1 ); ASSERT( b.appendAsNumber( "a" , "1" ) ); a.append( "b" , 1.1 ); ASSERT( b.appendAsNumber( "b" , "1.1" ) ); a.append( "c" , (int)-1 ); ASSERT( b.appendAsNumber( "c" , "-1" ) ); a.append( "d" , -1.1 ); ASSERT( b.appendAsNumber( "d" , "-1.1" ) ); a.append( "e" , (long long)32131231231232313LL ); ASSERT( b.appendAsNumber( "e" , "32131231231232313" ) ); ASSERT( ! b.appendAsNumber( "f" , "zz" ) ); ASSERT( ! b.appendAsNumber( "f" , "5zz" ) ); ASSERT( ! b.appendAsNumber( "f" , "zz5" ) ); ASSERT_EQUALS( a.obj() , b.obj() ); } }; class bson2settest { public: void run() { BSONObj o = BSON( "z" << 1 << "a" << 2 << "m" << 3 << "c" << 4 ); BSONObjIteratorSorted i( o ); stringstream ss; while ( i.more() ) ss << i.next().fieldName(); ASSERT_EQUALS( "acmz" , ss.str() ); { Timer t; for ( int i=0; i<10000; i++ ) { BSONObjIteratorSorted j( o ); int l = 0; while ( j.more() ) l += strlen( j.next().fieldName() ); } //unsigned long long tm = t.micros(); //cout << "time: " << tm << endl; } } }; class checkForStorageTests { public: void good( string s ) { BSONObj o = fromjson( s ); if ( o.okForStorage() ) return; throw UserException( 12528 , (string)"should be ok for storage:" + s ); } void bad( string s ) { BSONObj o = fromjson( s ); if ( ! o.okForStorage() ) return; throw UserException( 12529 , (string)"should NOT be ok for storage:" + s ); } void run() { good( "{x:1}" ); bad( "{'x.y':1}" ); good( "{x:{a:2}}" ); bad( "{x:{'$a':2}}" ); } }; class InvalidIDFind { public: void run() { BSONObj x = BSON( "_id" << 5 << "t" << 2 ); { char * crap = (char*)malloc( x.objsize() ); memcpy( crap , x.objdata() , x.objsize() ); BSONObj y( crap ); ASSERT_EQUALS( x , y ); free( crap ); } { char * crap = (char*)malloc( x.objsize() ); memcpy( crap , x.objdata() , x.objsize() ); int * foo = (int*)crap; foo[0] = 123123123; int state = 0; try { BSONObj y( crap ); state = 1; } catch ( std::exception& e ) { state = 2; ASSERT( strstr( e.what() , "_id: 5" ) > 0 ); } free( crap ); ASSERT_EQUALS( 2 , state ); } } }; class ElementSetTest { public: void run() { BSONObj x = BSON( "a" << 1 << "b" << 1 << "c" << 2 ); BSONElement a = x["a"]; BSONElement b = x["b"]; BSONElement c = x["c"]; //cout << "c: " << c << endl; ASSERT( a.woCompare( b ) != 0 ); ASSERT( a.woCompare( b , false ) == 0 ); BSONElementSet s; s.insert( a ); ASSERT_EQUALS( 1U , s.size() ); s.insert( b ); ASSERT_EQUALS( 1U , s.size() ); ASSERT( ! s.count( c ) ); ASSERT( s.find( a ) != s.end() ); ASSERT( s.find( b ) != s.end() ); ASSERT( s.find( c ) == s.end() ); s.insert( c ); ASSERT_EQUALS( 2U , s.size() ); ASSERT( s.find( a ) != s.end() ); ASSERT( s.find( b ) != s.end() ); ASSERT( s.find( c ) != s.end() ); ASSERT( s.count( a ) ); ASSERT( s.count( b ) ); ASSERT( s.count( c ) ); { BSONElementSet x; BSONObj o = fromjson( "{ 'a' : [ 1 , 2 , 1 ] }" ); BSONObjIterator i( o["a"].embeddedObjectUserCheck() ); while ( i.more() ) { x.insert( i.next() ); } ASSERT_EQUALS( 2U , x.size() ); } } }; class EmbeddedNumbers { public: void run() { BSONObj x = BSON( "a" << BSON( "b" << 1 ) ); BSONObj y = BSON( "a" << BSON( "b" << 1.0 ) ); keyTest(x); keyTest(y); ASSERT_EQUALS( x , y ); ASSERT_EQUALS( 0 , x.woCompare( y ) ); } }; class BuilderPartialItearte { public: void run() { { BSONObjBuilder b; b.append( "x" , 1 ); b.append( "y" , 2 ); BSONObjIterator i = b.iterator(); ASSERT( i.more() ); ASSERT_EQUALS( 1 , i.next().numberInt() ); ASSERT( i.more() ); ASSERT_EQUALS( 2 , i.next().numberInt() ); ASSERT( ! i.more() ); b.append( "z" , 3 ); i = b.iterator(); ASSERT( i.more() ); ASSERT_EQUALS( 1 , i.next().numberInt() ); ASSERT( i.more() ); ASSERT_EQUALS( 2 , i.next().numberInt() ); ASSERT( i.more() ); ASSERT_EQUALS( 3 , i.next().numberInt() ); ASSERT( ! i.more() ); ASSERT_EQUALS( BSON( "x" << 1 << "y" << 2 << "z" << 3 ) , b.obj() ); } } }; class BSONFieldTests { public: void run() { { BSONField x("x"); BSONObj o = BSON( x << 5 ); ASSERT_EQUALS( BSON( "x" << 5 ) , o ); } { BSONField x("x"); BSONObj o = BSON( x.make(5) ); ASSERT_EQUALS( BSON( "x" << 5 ) , o ); } { BSONField x("x"); BSONObj o = BSON( x(5) ); ASSERT_EQUALS( BSON( "x" << 5 ) , o ); o = BSON( x.gt(5) ); ASSERT_EQUALS( BSON( "x" << BSON( "$gt" << 5 ) ) , o ); } } }; class BSONForEachTest { public: void run() { BSONObj obj = BSON("a" << 1 << "a" << 2 << "a" << 3); int count = 0; BSONForEach(e, obj) { ASSERT_EQUALS( e.fieldName() , string("a") ); count += e.Int(); } ASSERT_EQUALS( count , 1+2+3 ); } }; class StringDataTest { public: void run() { StringData a( string( "aaa" ) ); ASSERT_EQUALS( 3u , a.size() ); StringData b( string( "bbb" ).c_str() ); ASSERT_EQUALS( 3u , b.size() ); StringData c( "ccc", StringData::LiteralTag() ); ASSERT_EQUALS( 3u , c.size() ); // TODO update test when second parm takes StringData too BSONObjBuilder builder; builder.append( c, "value"); ASSERT_EQUALS( builder.obj() , BSON( c.data() << "value" ) ); } }; class CompareOps { public: void run() { BSONObj a = BSON("a"<<1); BSONObj b = BSON("a"<<1); BSONObj c = BSON("a"<<2); BSONObj d = BSON("a"<<3); BSONObj e = BSON("a"<<4); BSONObj f = BSON("a"<<4); ASSERT( ! ( a < b ) ); ASSERT( a <= b ); ASSERT( a < c ); ASSERT( f > d ); ASSERT( f >= e ); ASSERT( ! ( f > e ) ); } }; class HashingTest { public: void run() { int N = 100000; BSONObj x = BSON( "name" << "eliot was here" << "x" << 5 << "asdasdasdas" << "asldkasldjasldjasldjlasjdlasjdlasdasdasdasdasdasdasd" ); { //Timer t; for ( int i=0; i(); add< BSONElementBasic >(); add< BSONObjTests::NullString >(); add< BSONObjTests::Create >(); add< BSONObjTests::WoCompareBasic >(); add< BSONObjTests::NumericCompareBasic >(); add< BSONObjTests::WoCompareEmbeddedObject >(); add< BSONObjTests::WoCompareEmbeddedArray >(); add< BSONObjTests::WoCompareOrdered >(); add< BSONObjTests::WoCompareDifferentLength >(); add< BSONObjTests::WoSortOrder >(); add< BSONObjTests::MultiKeySortOrder > (); add< BSONObjTests::TimestampTest >(); add< BSONObjTests::Nan >(); add< BSONObjTests::AsTempObj >(); add< BSONObjTests::AppendIntOrLL >(); add< BSONObjTests::AppendNumber >(); add< BSONObjTests::ToStringArray >(); add< BSONObjTests::ToStringNumber >(); add< BSONObjTests::AppendAs >(); add< BSONObjTests::ArrayAppendAs >(); add< BSONObjTests::GetField >(); add< BSONObjTests::Validation::BadType >(); add< BSONObjTests::Validation::EooBeforeEnd >(); add< BSONObjTests::Validation::Undefined >(); add< BSONObjTests::Validation::TotalSizeTooSmall >(); add< BSONObjTests::Validation::EooMissing >(); add< BSONObjTests::Validation::WrongStringSize >(); add< BSONObjTests::Validation::ZeroStringSize >(); add< BSONObjTests::Validation::NegativeStringSize >(); add< BSONObjTests::Validation::WrongSubobjectSize >(); add< BSONObjTests::Validation::WrongDbrefNsSize >(); add< BSONObjTests::Validation::NoFieldNameEnd >(); add< BSONObjTests::Validation::BadRegex >(); add< BSONObjTests::Validation::BadRegexOptions >(); add< BSONObjTests::Validation::CodeWScopeSmallSize >(); add< BSONObjTests::Validation::CodeWScopeZeroStrSize >(); add< BSONObjTests::Validation::CodeWScopeSmallStrSize >(); add< BSONObjTests::Validation::CodeWScopeNoSizeForObj >(); add< BSONObjTests::Validation::CodeWScopeSmallObjSize >(); add< BSONObjTests::Validation::CodeWScopeBadObject >(); add< BSONObjTests::Validation::NoSize >( Symbol ); add< BSONObjTests::Validation::NoSize >( Code ); add< BSONObjTests::Validation::NoSize >( String ); add< BSONObjTests::Validation::NoSize >( CodeWScope ); add< BSONObjTests::Validation::NoSize >( DBRef ); add< BSONObjTests::Validation::NoSize >( Object ); add< BSONObjTests::Validation::NoSize >( Array ); add< BSONObjTests::Validation::NoSize >( BinData ); add< BSONObjTests::Validation::Fuzz >( .5 ); add< BSONObjTests::Validation::Fuzz >( .1 ); add< BSONObjTests::Validation::Fuzz >( .05 ); add< BSONObjTests::Validation::Fuzz >( .01 ); add< BSONObjTests::Validation::Fuzz >( .001 ); add< OIDTests::init1 >(); add< OIDTests::initParse1 >(); add< OIDTests::append >(); add< OIDTests::increasing >(); add< OIDTests::ToDate >(); add< OIDTests::FromDate >(); add< ValueStreamTests::LabelBasic >(); add< ValueStreamTests::LabelShares >(); add< ValueStreamTests::LabelDouble >(); add< ValueStreamTests::LabelDoubleShares >(); add< ValueStreamTests::LabelSize >(); add< ValueStreamTests::LabelMulti >(); add< ValueStreamTests::LabelishOr >(); add< ValueStreamTests::Unallowed >(); add< ValueStreamTests::ElementAppend >(); add< ValueStreamTests::Unallowed >(); add< ValueStreamTests::ElementAppend >(); add< SubObjectBuilder >(); add< DateBuilder >(); add< DateNowBuilder >(); add< TimeTBuilder >(); add< MinMaxKeyBuilder >(); add< MinMaxElementTest >(); add< ComparatorTest >(); add< ExtractFieldsTest >(); add< external_sort::Basic1 >(); add< external_sort::Basic2 >(); add< external_sort::Basic3 >(); add< external_sort::ByDiskLock >(); add< external_sort::Big1 >(); add< external_sort::Big2 >(); add< external_sort::D1 >(); add< CompatBSON >(); add< CompareDottedFieldNamesTest >(); add< NestedDottedConversions >(); add< BSONArrayBuilderTest >(); add< ArrayMacroTest >(); add< NumberParsing >(); add< bson2settest >(); add< checkForStorageTests >(); add< InvalidIDFind >(); add< ElementSetTest >(); add< EmbeddedNumbers >(); add< BuilderPartialItearte >(); add< BSONFieldTests >(); add< BSONForEachTest >(); add< StringDataTest >(); add< CompareOps >(); add< HashingTest >(); } } myall; } // namespace JsobjTests