if ( 0 ) {

/* load the test documents */
load('jstests/aggregation/data/articles.js');

/* load the test utilities */
load('jstests/aggregation/extras/utils.js');

function removeVariants(ed) {
    // ignore the timing, since it may vary
    delete ed.serverPipeline[0].cursor.millis;

    // ignore the server the test runs on
    delete ed.serverPipeline[0].cursor.server;
}

/* sample aggregate explain command queries */
// make sure we're using the right db; this is the same as "use mydb;" in shell
db = db.getSisterDB("aggdb");

// $max, and averaging in a final projection; _id is structured
var eg2 = db.runCommand({ aggregate : "article", explain: true,
                          splitMongodPipeline: true, pipeline : [
    { $project : {
        author : 1,
        tags : 1,
        pageViews : 1
    }},
    { $unwind : "$tags" },
    { $group : {
        _id: { tags : 1 },
        docsByTag : { $sum : 1 },
        viewsByTag : { $sum : "$pageViews" },
        mostViewsByTag : { $max : "$pageViews" },
    }},
    { $project : {
        _id: false,
        tag : "$_id.tags",
        mostViewsByTag : 1,
        docsByTag : 1,
        viewsByTag : 1,
        avgByTag : { $divide:["$viewsByTag", "$docsByTag"] }
    }}
]});

removeVariants(eg2);

var eg2result = {
        "serverPipeline" : [
                {
                        "query" : {

                        },
                        "cursor" : {
                                "cursor" : "BasicCursor",
                                "isMultiKey" : false,
                                "n" : 3,
                                "nscannedObjects" : 3,
                                "nscanned" : 3,
                                "scanAndOrder" : false,
                                "indexOnly" : false,
                                "nYields" : 0,
                                "nChunkSkips" : 0,
                                "indexBounds" : {

                                },
                                "allPlans" : [
                                        {
                                                "cursor" : "BasicCursor",
                                                "n" : 3,
                                                "nscannedObjects" : 3,
                                                "nscanned" : 3,
                                                "indexBounds" : {

                                                }
                                        }
                                ]
                        }
                },
                {
                        "$project" : {
                                "author" : true,
                                "pageViews" : true,
                                "tags" : true
                        }
                },
                {
                        "$unwind" : "$tags"
                },
                {
                        "$group" : {
                                "_id" : {
                                        "tags" : true
                                },
                                "docsByTag" : {
                                        "$sum" : 1
                                },
                                "viewsByTag" : {
                                        "$sum" : "$pageViews"
                                },
                                "mostViewsByTag" : {
                                        "$max" : "$pageViews"
                                }
                        }
                }
        ],
        "mongosPipeline" : [
                {
                        "$group" : {
                                "_id" : "$_id",
                                "docsByTag" : {
                                        "$sum" : "$docsByTag"
                                },
                                "viewsByTag" : {
                                        "$sum" : "$viewsByTag"
                                },
                                "mostViewsByTag" : {
                                        "$max" : "$mostViewsByTag"
                                }
                        }
                },
                {
                        "$project" : {
                                "_id" : false,
                                "docsByTag" : true,
                                "mostViewsByTag" : true,
                                "viewsByTag" : true,
                                "tag" : "$_id.tags",
                                "avgByTag" : {
                                        "$divide" : [
                                                "$viewsByTag",
                                                "$docsByTag"
                                        ]
                                }
                        }
                }
        ],
        "ok" : 1
};

assert(documentEq(eg2, eg2result), 'eg2 failed');


db.digits.drop();
for(i = 0; i < 21; i += 2) db.digits.insert( { d : i } );
for(i = 1; i < 20; i += 2) db.digits.insert( { d : i } );

var ed1 = db.runCommand({ aggregate : "digits", explain: true, pipeline : [
    { $match: { d : {$gte : 5, $lte : 15}}}
]});

removeVariants(ed1);

var ed1result = {
        "serverPipeline" : [
                {
                        "query" : {
                                "d" : {
                                        "$gte" : 5,
                                        "$lte" : 15
                                }
                        },
                        "cursor" : {
                                "cursor" : "BasicCursor",
                                "isMultiKey" : false,
                                "n" : 11,
                                "nscannedObjects" : 21,
                                "nscanned" : 21,
                                "scanAndOrder" : false,
                                "indexOnly" : false,
                                "nYields" : 0,
                                "nChunkSkips" : 0,
                                "indexBounds" : {

                                },
                                "allPlans" : [
                                        {
                                                "cursor" : "BasicCursor",
                                                "n" : 11,
                                                "nscannedObjects" : 21,
                                                "nscanned" : 21,
                                                "indexBounds" : {

                                                }
                                        }
                                ]
                        }
                }
        ],
        "ok" : 1
};

assert(documentEq(ed1, ed1result), 'ed1 failed');


var ed2 = db.runCommand({ aggregate : "digits", explain: true, pipeline : [
    { $sort : { d : 1 } },
    { $skip : 5 },
    { $limit : 10 }
]});

removeVariants(ed2);

var ed2result = {
        "serverPipeline" : [
                {
                        "query" : {

                        },
                        "cursor" : {
                                "cursor" : "BasicCursor",
                                "isMultiKey" : false,
                                "n" : 21,
                                "nscannedObjects" : 21,
                                "nscanned" : 21,
                                "scanAndOrder" : false,
                                "indexOnly" : false,
                                "nYields" : 0,
                                "nChunkSkips" : 0,
                                "indexBounds" : {

                                },
                                "allPlans" : [
                                        {
                                                "cursor" : "BasicCursor",
                                                "n" : 21,
                                                "nscannedObjects" : 21,
                                                "nscanned" : 21,
                                                "indexBounds" : {

                                                }
                                        }
                                ]
                        }
                },
                {
                        "$sort" : {
                                "d" : 1
                        }
                },
                {
                        "$skip" : NumberLong(5)
                },
                {
                        "$limit" : NumberLong(10)
                }
        ],
        "ok" : 1
};

assert(documentEq(ed2, ed2result), 'ed2 failed');


var ed3 = db.runCommand({ aggregate : "digits", explain: true, pipeline : [
    { $match: { d : {$gte : 10, $lte : 20}}},
    { $sort : { d : 1 } },
    { $skip : 5 },
    { $limit : 10 }
]});

removeVariants(ed3);

var ed3result = {
        "serverPipeline" : [
                {
                        "query" : {
                                "d" : {
                                        "$gte" : 10,
                                        "$lte" : 20
                                }
                        },
                        "cursor" : {
                                "cursor" : "BasicCursor",
                                "isMultiKey" : false,
                                "n" : 11,
                                "nscannedObjects" : 21,
                                "nscanned" : 21,
                                "scanAndOrder" : false,
                                "indexOnly" : false,
                                "nYields" : 0,
                                "nChunkSkips" : 0,
                                "indexBounds" : {

                                },
                                "allPlans" : [
                                        {
                                                "cursor" : "BasicCursor",
                                                "n" : 11,
                                                "nscannedObjects" : 21,
                                                "nscanned" : 21,
                                                "indexBounds" : {

                                                }
                                        }
                                ]
                        }
                },
                {
                        "$sort" : {
                                "d" : 1
                        }
                },
                {
                        "$skip" : NumberLong(5)
                },
                {
                        "$limit" : NumberLong(10)
                }
        ],
        "ok" : 1
};

assert(documentEq(ed3, ed3result), 'ed3 failed');


/****
Repeat those last three with an index
*****/
db.digits.ensureIndex( { d : 1 } );


var edi1 = db.runCommand({ aggregate : "digits", explain: true, pipeline : [
    { $match: { d : {$gte : 5, $lte : 15}}}
]});

removeVariants(edi1);

var edi1result = {
        "serverPipeline" : [
                {
                        "query" : {
                                "d" : {
                                        "$gte" : 5,
                                        "$lte" : 15
                                }
                        },
                        "cursor" : {
                                "cursor" : "BtreeCursor d_1",
                                "isMultiKey" : false,
                                "n" : 11,
                                "nscannedObjects" : 11,
                                "nscanned" : 11,
                                "scanAndOrder" : false,
                                "indexOnly" : false,
                                "nYields" : 0,
                                "nChunkSkips" : 0,
                                "indexBounds" : {
                                        "d" : [
                                                [
                                                        5,
                                                        15
                                                ]
                                        ]
                                },
                                "allPlans" : [
                                        {
                                                "cursor" : "BtreeCursor d_1",
                                                "n" : 11,
                                                "nscannedObjects" : 11,
                                                "nscanned" : 11,
                                                "indexBounds" : {
                                                        "d" : [
                                                                [
                                                                        5,
                                                                        15
                                                                ]
                                                        ]
                                                }
                                        }
                                ],
                                "oldPlan" : {
                                        "cursor" : "BtreeCursor d_1",
                                        "indexBounds" : {
                                                "d" : [
                                                        [
                                                                5,
                                                                15
                                                        ]
                                                ]
                                        }
                                }
                        }
                }
        ],
        "ok" : 1
};

assert(documentEq(edi1, edi1result), 'edi1 failed');


var edi2 = db.runCommand({ aggregate : "digits", explain: true, pipeline : [
    { $sort : { d : 1 } },
    { $skip : 5 },
    { $limit : 10 }
]});

removeVariants(edi2);

var edi2result = {
    "serverPipeline" : [
        {
            "query" : {
                
            },
            "sort" : {
                "d" : 1
            },
            "cursor" : {
                "cursor" : "BtreeCursor d_1",
                "isMultiKey" : false,
                "n" : 21,
                "nscannedObjects" : 21,
                "nscanned" : 21,
                "scanAndOrder" : false,
                "indexOnly" : false,
                "nYields" : 0,
                "nChunkSkips" : 0,
                "indexBounds" : {
                    "d" : [
                        [
                            {
                                "$minElement" : 1
                            },
                            {
                                "$maxElement" : 1
                            }
                        ]
                    ]
                },
                "allPlans" : [
                    {
                        "cursor" : "BtreeCursor d_1",
                        "n" : 21,
                        "nscannedObjects" : 21,
                        "nscanned" : 21,
                        "indexBounds" : {
                            "d" : [
                                [
                                    {
                                        "$minElement" : 1
                                    },
                                    {
                                        "$maxElement" : 1
                                    }
                                ]
                            ]
                        }
                    }
                ],
                "oldPlan" : {
                    "cursor" : "BtreeCursor d_1",
                    "indexBounds" : {
                        "d" : [
                            [
                                {
                                    "$minElement" : 1
                                },
                                {
                                    "$maxElement" : 1
                                }
                            ]
                        ]
                    }
                }
            }
        },
        {
            "$skip" : NumberLong(5)
        },
        {
            "$limit" : NumberLong(10)
        }
    ],
    "ok" : 1
};

assert(documentEq(edi2, edi2result), 'edi2 failed');


var edi3 = db.runCommand({ aggregate : "digits", explain: true, pipeline : [
    { $match: { d : {$gte : 10, $lte : 20}}},
    { $sort : { d : 1 } },
    { $skip : 5 },
    { $limit : 10 }
]});

removeVariants(edi3);

var edi3result = {
        "serverPipeline" : [
                {
                        "query" : {
                                "d" : {
                                        "$gte" : 10,
                                        "$lte" : 20
                                }
                        },
                        "sort" : {
                                "d" : 1
                        },
                        "cursor" : {
                                "cursor" : "BtreeCursor d_1",
                                "isMultiKey" : false,
                                "n" : 11,
                                "nscannedObjects" : 11,
                                "nscanned" : 11,
                                "scanAndOrder" : false,
                                "indexOnly" : false,
                                "nYields" : 0,
                                "nChunkSkips" : 0,
                                "indexBounds" : {
                                        "d" : [
                                                [
                                                        10,
                                                        20
                                                ]
                                        ]
                                },
                                "allPlans" : [
                                        {
                                                "cursor" : "BtreeCursor d_1",
                                                "n" : 11,
                                                "nscannedObjects" : 11,
                                                "nscanned" : 11,
                                                "indexBounds" : {
                                                        "d" : [
                                                                [
                                                                        10,
                                                                        20
                                                                ]
                                                        ]
                                                }
                                        }
                                ],
                                "oldPlan" : {
                                        "cursor" : "BtreeCursor d_1",
                                        "indexBounds" : {
                                                "d" : [
                                                        [
                                                                10,
                                                                20
                                                        ]
                                                ]
                                        }
                                }
                        }
                },
                {
                        "$skip" : NumberLong(5)
                },
                {
                        "$limit" : NumberLong(10)
                }
        ],
    "ok" : 1
};

assert(documentEq(edi3, edi3result), 'edi3 failed');

}