← Back to branch summary

~evarlast/ubuntu/utopic/mongodb/upstart-workaround-debian-bug-718702

« back to all changes in this revision

Viewing changes to src/mongo/dbtests/jsobjtests.cpp

  • Committer: Package Import Robot
  • Author(s): James Page, James Page, Robie Basak
  • Date: 2013-05-29 17:44:42 UTC
  • mfrom: (44.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20130529174442-z0a4qmoww4y0t458
Tags: 1:2.4.3-1ubuntu1
[ James Page ]
* Merge from Debian unstable, remaining changes:
  - Enable SSL support:
    + d/control: Add libssl-dev to BD's.
    + d/rules: Enabled --ssl option.
    + d/mongodb.conf: Add example SSL configuration options.
  - d/mongodb-server.mongodb.upstart: Add upstart configuration.
  - d/rules: Don't strip binaries during scons build for Ubuntu.
  - d/control: Add armhf to target archs.
  - d/p/SConscript.client.patch: fixup install of client libraries.
  - d/p/0010-install-libs-to-usr-lib-not-usr-lib64-Closes-588557.patch:
    Install libraries to lib not lib64.
* Dropped changes:
  - d/p/arm-support.patch: Included in Debian.
  - d/p/double-alignment.patch: Included in Debian.
  - d/rules,control: Debian also builds with avaliable system libraries
    now.
* Fix FTBFS due to gcc and boost upgrades in saucy:
  - d/p/0008-ignore-unused-local-typedefs.patch: Add -Wno-unused-typedefs
    to unbreak building with g++-4.8.
  - d/p/0009-boost-1.53.patch: Fixup signed/unsigned casting issue.

[ Robie Basak ]
* d/p/0011-Use-a-signed-char-to-store-BSONType-enumerations.patch: Fixup
  build failure on ARM due to missing signed'ness of char cast.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mongo/dbtests/jsobjtests.cpp
23
23
#include "../db/jsobjmanipulator.h"
24
24
#include "../db/json.h"
25
25
#include "../db/repl.h"
26
 
#include "../db/extsort.h"
27
26
#include "dbtests.h"
28
27
#include "../util/stringutils.h"
29
28
#include "../util/mongoutils/checksum.h"
30
29
#include "../db/key.h"
31
 
#include "../db/btree.h"
32
30
#include "mongo/platform/float_utils.h"
33
31
 
34
32
namespace JsobjTests {
35
33
 
36
 
    IndexInterface& indexInterfaceForTheseTests = (time(0)%2) ? *IndexDetails::iis[0] : *IndexDetails::iis[1];
37
 
 
38
34
    void keyTest(const BSONObj& o, bool mustBeCompact = false) {
39
35
        static KeyV1Owned *kLast;
40
36
        static BSONObj last;
198
194
                    verify( ! k.isPrefixOf( BSON( "x" << "hi" ) ) );
199
195
                    verify( k.isPrefixOf( BSON( "x" << 1 << "a" << "hi" ) ) );
200
196
                }
 
197
                {
 
198
                    BSONObj k = BSON( "x" << 1 );
 
199
                    verify( k.isFieldNamePrefixOf( BSON( "x" << "hi" ) ) );
 
200
                    verify( ! k.isFieldNamePrefixOf( BSON( "a" << 1  ) ) );
 
201
                }
201
202
            }
202
203
        };
203
204
 
611
612
                        ASSERT( a.woCompare(b, Ordering::make(BSONObj())) > 0 );
612
613
                    }
613
614
                    {
614
 
                        // this is an uncompactible key:
 
615
                        // this is an uncompactable key:
615
616
                        BSONObj uc1 = BSONObjBuilder().appendDate("", -50).appendCode("", "abc").obj();
616
617
                        BSONObj uc2 = BSONObjBuilder().appendDate("", 55).appendCode("", "abc").obj();
617
618
                        ASSERT( uc1.woCompare(uc2, Ordering::make(BSONObj())) < 0 );
1140
1141
                BSONType type_;
1141
1142
            };
1142
1143
 
1143
 
            // Randomized BSON parsing test.  See if we seg fault.
1144
 
            // NOTE This test is disabled (below), see SERVER-4948.
1145
 
            class Fuzz {
1146
 
            public:
1147
 
                Fuzz( double frequency ) : frequency_( frequency ) {}
1148
 
                void run() {
1149
 
                    BSONObj a = fromjson( "{\"a\": 1, \"b\": \"c\"}" );
1150
 
                    fuzz( a );
1151
 
                    a.valid();
1152
 
 
1153
 
                    BSONObj b = fromjson( "{\"one\":2, \"two\":5, \"three\": {},"
1154
 
                                          "\"four\": { \"five\": { \"six\" : 11 } },"
1155
 
                                          "\"seven\": [ \"a\", \"bb\", \"ccc\", 5 ],"
1156
 
                                          "\"eight\": Dbref( \"rrr\", \"01234567890123456789aaaa\" ),"
1157
 
                                          "\"_id\": ObjectId( \"deadbeefdeadbeefdeadbeef\" ),"
1158
 
                                          "\"nine\": { \"$binary\": \"abc=\", \"$type\": \"00\" },"
1159
 
                                          "\"ten\": Date( 44 ), \"eleven\": /foooooo/i }" );
1160
 
                    fuzz( b );
1161
 
                    b.valid();
1162
 
                }
1163
 
            private:
1164
 
                void fuzz( BSONObj &o ) const {
1165
 
                    for( int i = 4; i < o.objsize(); ++i )
1166
 
                        for( unsigned char j = 1; j; j <<= 1 )
1167
 
                            if ( rand() < int( RAND_MAX * frequency_ ) ) {
1168
 
                                char *c = const_cast< char * >( o.objdata() ) + i;
1169
 
                                if ( *c & j )
1170
 
                                    *c &= ~j;
1171
 
                                else
1172
 
                                    *c |= j;
1173
 
                            }
1174
 
                }
1175
 
                double frequency_;
1176
 
            };
1177
 
 
1178
1144
        } // namespace Validation
1179
1145
 
1180
1146
    } // namespace BSONObjTests
1410
1376
            }
1411
1377
        };
1412
1378
 
 
1379
        class AllTypes {
 
1380
        public:
 
1381
            void run() {
 
1382
                // These are listed in order of BSONType
 
1383
 
 
1384
                ASSERT_EQUALS(objTypeOf(MINKEY), MinKey);
 
1385
                ASSERT_EQUALS(arrTypeOf(MINKEY), MinKey);
 
1386
 
 
1387
                // EOO not valid in middle of BSONObj
 
1388
 
 
1389
                ASSERT_EQUALS(objTypeOf(1.0), NumberDouble);
 
1390
                ASSERT_EQUALS(arrTypeOf(1.0), NumberDouble);
 
1391
 
 
1392
                ASSERT_EQUALS(objTypeOf(""), String);
 
1393
                ASSERT_EQUALS(arrTypeOf(""), String);
 
1394
                ASSERT_EQUALS(objTypeOf(string()), String);
 
1395
                ASSERT_EQUALS(arrTypeOf(string()), String);
 
1396
                ASSERT_EQUALS(objTypeOf(StringData("")), String);
 
1397
                ASSERT_EQUALS(arrTypeOf(StringData("")), String);
 
1398
 
 
1399
                ASSERT_EQUALS(objTypeOf(BSONObj()), Object);
 
1400
                ASSERT_EQUALS(arrTypeOf(BSONObj()), Object);
 
1401
 
 
1402
                ASSERT_EQUALS(objTypeOf(BSONArray()), Array);
 
1403
                ASSERT_EQUALS(arrTypeOf(BSONArray()), Array);
 
1404
 
 
1405
                ASSERT_EQUALS(objTypeOf(BSONBinData("", 0, BinDataGeneral)), BinData);
 
1406
                ASSERT_EQUALS(arrTypeOf(BSONBinData("", 0, BinDataGeneral)), BinData);
 
1407
 
 
1408
                ASSERT_EQUALS(objTypeOf(BSONUndefined), Undefined);
 
1409
                ASSERT_EQUALS(arrTypeOf(BSONUndefined), Undefined);
 
1410
 
 
1411
                ASSERT_EQUALS(objTypeOf(OID()), jstOID);
 
1412
                ASSERT_EQUALS(arrTypeOf(OID()), jstOID);
 
1413
 
 
1414
                ASSERT_EQUALS(objTypeOf(true), Bool);
 
1415
                ASSERT_EQUALS(arrTypeOf(true), Bool);
 
1416
 
 
1417
                ASSERT_EQUALS(objTypeOf(Date_t()), Date);
 
1418
                ASSERT_EQUALS(arrTypeOf(Date_t()), Date);
 
1419
 
 
1420
                ASSERT_EQUALS(objTypeOf(BSONNULL), jstNULL);
 
1421
                ASSERT_EQUALS(arrTypeOf(BSONNULL), jstNULL);
 
1422
 
 
1423
                ASSERT_EQUALS(objTypeOf(BSONRegEx("", "")), RegEx);
 
1424
                ASSERT_EQUALS(arrTypeOf(BSONRegEx("", "")), RegEx);
 
1425
 
 
1426
                ASSERT_EQUALS(objTypeOf(BSONDBRef("", OID())), DBRef);
 
1427
                ASSERT_EQUALS(arrTypeOf(BSONDBRef("", OID())), DBRef);
 
1428
 
 
1429
                ASSERT_EQUALS(objTypeOf(BSONCode("")), Code);
 
1430
                ASSERT_EQUALS(arrTypeOf(BSONCode("")), Code);
 
1431
 
 
1432
                ASSERT_EQUALS(objTypeOf(BSONSymbol("")), Symbol);
 
1433
                ASSERT_EQUALS(arrTypeOf(BSONSymbol("")), Symbol);
 
1434
 
 
1435
                ASSERT_EQUALS(objTypeOf(BSONCodeWScope("", BSONObj())), CodeWScope);
 
1436
                ASSERT_EQUALS(arrTypeOf(BSONCodeWScope("", BSONObj())), CodeWScope);
 
1437
 
 
1438
                ASSERT_EQUALS(objTypeOf(1), NumberInt);
 
1439
                ASSERT_EQUALS(arrTypeOf(1), NumberInt);
 
1440
 
 
1441
                ASSERT_EQUALS(objTypeOf(OpTime()), Timestamp);
 
1442
                ASSERT_EQUALS(arrTypeOf(OpTime()), Timestamp);
 
1443
 
 
1444
                ASSERT_EQUALS(objTypeOf(1LL), NumberLong);
 
1445
                ASSERT_EQUALS(arrTypeOf(1LL), NumberLong);
 
1446
 
 
1447
                ASSERT_EQUALS(objTypeOf(MAXKEY), MaxKey);
 
1448
                ASSERT_EQUALS(arrTypeOf(MAXKEY), MaxKey);
 
1449
            }
 
1450
 
 
1451
            template<typename T>
 
1452
            BSONType objTypeOf(const T& thing) {
 
1453
                return BSON("" << thing).firstElement().type();
 
1454
            }
 
1455
 
 
1456
            template<typename T>
 
1457
            BSONType arrTypeOf(const T& thing) {
 
1458
                return BSON_ARRAY(thing).firstElement().type();
 
1459
            }
 
1460
        };
1413
1461
    } // namespace ValueStreamTests
1414
1462
 
1415
1463
    class SubObjectBuilder {
1578
1626
        }
1579
1627
    };
1580
1628
 
1581
 
    namespace external_sort {
1582
 
        class Basic1 {
1583
 
        public:
1584
 
            void run() {
1585
 
                BSONObjExternalSorter sorter(indexInterfaceForTheseTests);
1586
 
 
1587
 
                sorter.add( BSON( "x" << 10 ) , 5  , 1);
1588
 
                sorter.add( BSON( "x" << 2 ) , 3 , 1 );
1589
 
                sorter.add( BSON( "x" << 5 ) , 6 , 1 );
1590
 
                sorter.add( BSON( "x" << 5 ) , 7 , 1 );
1591
 
 
1592
 
                sorter.sort();
1593
 
 
1594
 
                auto_ptr<BSONObjExternalSorter::Iterator> i = sorter.iterator();
1595
 
                int num=0;
1596
 
                while ( i->more() ) {
1597
 
                    pair<BSONObj,DiskLoc> p = i->next();
1598
 
                    if ( num == 0 )
1599
 
                        verify( p.first["x"].number() == 2 );
1600
 
                    else if ( num <= 2 ) {
1601
 
                        verify( p.first["x"].number() == 5 );
1602
 
                    }
1603
 
                    else if ( num == 3 )
1604
 
                        verify( p.first["x"].number() == 10 );
1605
 
                    else
1606
 
                        ASSERT( 0 );
1607
 
                    num++;
1608
 
                }
1609
 
 
1610
 
 
1611
 
                ASSERT_EQUALS( 0 , sorter.numFiles() );
1612
 
            }
1613
 
        };
1614
 
 
1615
 
        class Basic2 {
1616
 
        public:
1617
 
            void run() {
1618
 
                BSONObjExternalSorter sorter( indexInterfaceForTheseTests, BSONObj() , 10 );
1619
 
                sorter.add( BSON( "x" << 10 ) , 5  , 11 );
1620
 
                sorter.add( BSON( "x" << 2 ) , 3 , 1 );
1621
 
                sorter.add( BSON( "x" << 5 ) , 6 , 1 );
1622
 
                sorter.add( BSON( "x" << 5 ) , 7 , 1 );
1623
 
 
1624
 
                sorter.sort();
1625
 
 
1626
 
                auto_ptr<BSONObjExternalSorter::Iterator> i = sorter.iterator();
1627
 
                int num=0;
1628
 
                while ( i->more() ) {
1629
 
                    pair<BSONObj,DiskLoc> p = i->next();
1630
 
                    if ( num == 0 ) {
1631
 
                        verify( p.first["x"].number() == 2 );
1632
 
                        ASSERT_EQUALS( p.second.toString() , "3:1" );
1633
 
                    }
1634
 
                    else if ( num <= 2 )
1635
 
                        verify( p.first["x"].number() == 5 );
1636
 
                    else if ( num == 3 ) {
1637
 
                        verify( p.first["x"].number() == 10 );
1638
 
                        ASSERT_EQUALS( p.second.toString() , "5:b" );
1639
 
                    }
1640
 
                    else
1641
 
                        ASSERT( 0 );
1642
 
                    num++;
1643
 
                }
1644
 
 
1645
 
            }
1646
 
        };
1647
 
 
1648
 
        class Basic3 {
1649
 
        public:
1650
 
            void run() {
1651
 
                BSONObjExternalSorter sorter( indexInterfaceForTheseTests, BSONObj() , 10 );
1652
 
                sorter.sort();
1653
 
 
1654
 
                auto_ptr<BSONObjExternalSorter::Iterator> i = sorter.iterator();
1655
 
                verify( ! i->more() );
1656
 
 
1657
 
            }
1658
 
        };
1659
 
 
1660
 
 
1661
 
        class ByDiskLock {
1662
 
        public:
1663
 
            void run() {
1664
 
                BSONObjExternalSorter sorter(indexInterfaceForTheseTests);
1665
 
                sorter.add( BSON( "x" << 10 ) , 5  , 4);
1666
 
                sorter.add( BSON( "x" << 2 ) , 3 , 0 );
1667
 
                sorter.add( BSON( "x" << 5 ) , 6 , 2 );
1668
 
                sorter.add( BSON( "x" << 5 ) , 7 , 3 );
1669
 
                sorter.add( BSON( "x" << 5 ) , 2 , 1 );
1670
 
 
1671
 
                sorter.sort();
1672
 
 
1673
 
                auto_ptr<BSONObjExternalSorter::Iterator> i = sorter.iterator();
1674
 
                int num=0;
1675
 
                while ( i->more() ) {
1676
 
                    pair<BSONObj,DiskLoc> p = i->next();
1677
 
                    if ( num == 0 )
1678
 
                        verify( p.first["x"].number() == 2 );
1679
 
                    else if ( num <= 3 ) {
1680
 
                        verify( p.first["x"].number() == 5 );
1681
 
                    }
1682
 
                    else if ( num == 4 )
1683
 
                        verify( p.first["x"].number() == 10 );
1684
 
                    else
1685
 
                        ASSERT( 0 );
1686
 
                    ASSERT_EQUALS( num , p.second.getOfs() );
1687
 
                    num++;
1688
 
                }
1689
 
 
1690
 
 
1691
 
            }
1692
 
        };
1693
 
 
1694
 
 
1695
 
        class Big1 {
1696
 
        public:
1697
 
            void run() {
1698
 
                BSONObjExternalSorter sorter( indexInterfaceForTheseTests, BSONObj() , 2000 );
1699
 
                for ( int i=0; i<10000; i++ ) {
1700
 
                    sorter.add( BSON( "x" << rand() % 10000 ) , 5  , i );
1701
 
                }
1702
 
 
1703
 
                sorter.sort();
1704
 
 
1705
 
                auto_ptr<BSONObjExternalSorter::Iterator> i = sorter.iterator();
1706
 
                int num=0;
1707
 
                double prev = 0;
1708
 
                while ( i->more() ) {
1709
 
                    pair<BSONObj,DiskLoc> p = i->next();
1710
 
                    num++;
1711
 
                    double cur = p.first["x"].number();
1712
 
                    verify( cur >= prev );
1713
 
                    prev = cur;
1714
 
                }
1715
 
                verify( num == 10000 );
1716
 
            }
1717
 
        };
1718
 
 
1719
 
        class Big2 {
1720
 
        public:
1721
 
            void run() {
1722
 
                const int total = 100000;
1723
 
                BSONObjExternalSorter sorter( indexInterfaceForTheseTests, BSONObj() , total * 2 );
1724
 
                for ( int i=0; i<total; i++ ) {
1725
 
                    sorter.add( BSON( "a" << "b" ) , 5  , i );
1726
 
                }
1727
 
 
1728
 
                sorter.sort();
1729
 
 
1730
 
                auto_ptr<BSONObjExternalSorter::Iterator> i = sorter.iterator();
1731
 
                int num=0;
1732
 
                double prev = 0;
1733
 
                while ( i->more() ) {
1734
 
                    pair<BSONObj,DiskLoc> p = i->next();
1735
 
                    num++;
1736
 
                    double cur = p.first["x"].number();
1737
 
                    verify( cur >= prev );
1738
 
                    prev = cur;
1739
 
                }
1740
 
                verify( num == total );
1741
 
                ASSERT( sorter.numFiles() > 2 );
1742
 
            }
1743
 
        };
1744
 
 
1745
 
 
1746
 
        class Big3 {
1747
 
        public:
1748
 
            void run() {
1749
 
                const int total = 1000 * 1000;
1750
 
                BSONObjExternalSorter sorter( indexInterfaceForTheseTests, BSONObj() , total * 2 );
1751
 
                for ( int i=0; i<total; i++ ) {
1752
 
                    sorter.add( BSON( "abcabcabcabd" << "basdasdasdasdasdasdadasdasd" << "x" << i ) , 5  , i );
1753
 
                }
1754
 
 
1755
 
                sorter.sort();
1756
 
 
1757
 
                auto_ptr<BSONObjExternalSorter::Iterator> i = sorter.iterator();
1758
 
                int num=0;
1759
 
                double prev = 0;
1760
 
                while ( i->more() ) {
1761
 
                    pair<BSONObj,DiskLoc> p = i->next();
1762
 
                    num++;
1763
 
                    double cur = p.first["x"].number();
1764
 
                    verify( cur >= prev );
1765
 
                    prev = cur;
1766
 
                }
1767
 
                verify( num == total );
1768
 
                ASSERT( sorter.numFiles() > 2 );
1769
 
            }
1770
 
        };
1771
 
 
1772
 
 
1773
 
        class D1 {
1774
 
        public:
1775
 
            void run() {
1776
 
 
1777
 
                BSONObjBuilder b;
1778
 
                b.appendNull("");
1779
 
                BSONObj x = b.obj();
1780
 
 
1781
 
                BSONObjExternalSorter sorter(indexInterfaceForTheseTests);
1782
 
                sorter.add(x, DiskLoc(3,7));
1783
 
                sorter.add(x, DiskLoc(4,7));
1784
 
                sorter.add(x, DiskLoc(2,7));
1785
 
                sorter.add(x, DiskLoc(1,7));
1786
 
                sorter.add(x, DiskLoc(3,77));
1787
 
 
1788
 
                sorter.sort();
1789
 
 
1790
 
                auto_ptr<BSONObjExternalSorter::Iterator> i = sorter.iterator();
1791
 
                while( i->more() ) {
1792
 
                    BSONObjExternalSorter::Data d = i->next();
1793
 
                    /*cout << d.second.toString() << endl;
1794
 
                    cout << d.first.objsize() << endl;
1795
 
                    cout<<"SORTER next:" << d.first.toString() << endl;*/
1796
 
                }
1797
 
            }
1798
 
        };
1799
 
    }
1800
 
 
1801
1629
    class CompatBSON {
1802
1630
    public:
1803
1631
 
2166
1994
        }
2167
1995
    };
2168
1996
 
2169
 
    class BSONFieldTests {
2170
 
    public:
2171
 
        void run() {
2172
 
            {
2173
 
                BSONField<int> x("x");
2174
 
                BSONObj o = BSON( x << 5 );
2175
 
                ASSERT_EQUALS( BSON( "x" << 5 ) , o );
2176
 
            }
2177
 
 
2178
 
            {
2179
 
                BSONField<int> x("x");
2180
 
                BSONObj o = BSON( x.make(5) );
2181
 
                ASSERT_EQUALS( BSON( "x" << 5 ) , o );
2182
 
            }
2183
 
 
2184
 
            {
2185
 
                BSONField<int> x("x");
2186
 
                BSONObj o = BSON( x(5) );
2187
 
                ASSERT_EQUALS( BSON( "x" << 5 ) , o );
2188
 
 
2189
 
                o = BSON( x.gt(5) );
2190
 
                ASSERT_EQUALS( BSON( "x" << BSON( "$gt" << 5 ) ) , o );
2191
 
            }
2192
 
 
2193
 
        }
2194
 
    };
2195
 
 
2196
1997
    class BSONForEachTest {
2197
1998
    public:
2198
1999
        void run() {
2208
2009
        }
2209
2010
    };
2210
2011
 
2211
 
    class StringDataTest {
2212
 
    public:
2213
 
        void run() {
2214
 
            ASSERT( string::npos != 0 );
2215
 
            std::string s1("aaa");
2216
 
            
2217
 
            StringData a(s1);
2218
 
            ASSERT_EQUALS(3u, a.size());
2219
 
 
2220
 
            StringData b(s1.c_str());
2221
 
            ASSERT_EQUALS(3u, b.size());
2222
 
 
2223
 
            StringData c("ccc", StringData::LiteralTag());
2224
 
            ASSERT_EQUALS(3u , c.size());
2225
 
 
2226
 
            // TODO update test when second parm takes StringData too
2227
 
            BSONObjBuilder builder;
2228
 
            builder.append( c, "value");
2229
 
            ASSERT_EQUALS( builder.obj() , BSON( c.data() << "value" ) );
2230
 
 
2231
 
        }
2232
 
    };
2233
 
 
2234
2012
    class CompareOps {
2235
2013
    public:
2236
2014
        void run() {
2346
2124
            add< BSONObjTests::Validation::NoSize >( Object );
2347
2125
            add< BSONObjTests::Validation::NoSize >( Array );
2348
2126
            add< BSONObjTests::Validation::NoSize >( BinData );
2349
 
            if ( 0 ) { // SERVER-4948
2350
 
            add< BSONObjTests::Validation::Fuzz >( .5 );
2351
 
            add< BSONObjTests::Validation::Fuzz >( .1 );
2352
 
            add< BSONObjTests::Validation::Fuzz >( .05 );
2353
 
            add< BSONObjTests::Validation::Fuzz >( .01 );
2354
 
            add< BSONObjTests::Validation::Fuzz >( .001 );
2355
 
            }
2356
2127
            add< OIDTests::init1 >();
2357
2128
            add< OIDTests::initParse1 >();
2358
2129
            add< OIDTests::append >();
2369
2140
            add< ValueStreamTests::LabelishOr >();
2370
2141
            add< ValueStreamTests::Unallowed >();
2371
2142
            add< ValueStreamTests::ElementAppend >();
 
2143
            add< ValueStreamTests::AllTypes >();
2372
2144
            add< SubObjectBuilder >();
2373
2145
            add< DateBuilder >();
2374
2146
            add< DateNowBuilder >();
2377
2149
            add< MinMaxElementTest >();
2378
2150
            add< ComparatorTest >();
2379
2151
            add< ExtractFieldsTest >();
2380
 
            add< external_sort::Basic1 >();
2381
 
            add< external_sort::Basic2 >();
2382
 
            add< external_sort::Basic3 >();
2383
 
            add< external_sort::ByDiskLock >();
2384
 
            add< external_sort::Big1 >();
2385
 
            add< external_sort::Big2 >();
2386
 
            add< external_sort::Big3 >();
2387
 
            add< external_sort::D1 >();
2388
2152
            add< CompatBSON >();
2389
2153
            add< CompareDottedFieldNamesTest >();
2390
2154
            add< CompareDottedArrayFieldNamesTest >();
2399
2163
            add< ElementSetTest >();
2400
2164
            add< EmbeddedNumbers >();
2401
2165
            add< BuilderPartialItearte >();
2402
 
            add< BSONFieldTests >();
2403
2166
            add< BSONForEachTest >();
2404
 
            add< StringDataTest >();
2405
2167
            add< CompareOps >();
2406
2168
            add< HashingTest >();
2407
2169
        }