windows-server-2003/ds/security/azroles/tests/aztest.c

/*--

Copyright (c) 1987-1993  Microsoft Corporation

Module Name:

    aztest.c

Abstract:

    Test program for the azroles DLL.

Author:

    Cliff Van Dyke (cliffv) 16-Apr-2001

Environment:

    User mode only.
    Contains NT-specific code.
    Requires ANSI C extensions: slash-slash comments, long external names.

Revision History:

--*/


//
// Common include files.
//

#define UNICODE 1
// #define SECURITY_WIN32 1
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include "azrolesp.h"
#include <lmcons.h>
#include <lmerr.h>
#include <stdio.h>      // printf
#include <sddl.h>
#include <ntstatus.dbg>
#include <winerror.dbg>

//
// Sundry defines to enable optional tests
//

// #define ENABLE_LEAK 1           // Run a test that leaks memory
// #define ENABLE_CAUGHT_AVS 1     // Run a test that AVs in azroles.dll (but the AV is caught)
// #define ENABLE_LOCAL_ACCOUNT 1  // Run tests with user logged onto a local account
// #define ENABLE_NT4_ACCOUNT 1    // Run tests with user logged onto an NT4 domain account
//#define ENABLE_CHAITU_ACCOUNT 1  // Run tests as CHAITU
// #define ENABLE_CLIFFV_ACCOUNT 1 // Run tests as CLIFFV
#define ENABLE_ADMIN_ACCOUNT_XML 1 // Run tests as CLIFFVDOM\Administrator (on XML store)
// #define ENABLE_ADMIN_ACCOUNT_AD 1  // Run tests as CLIFFVDOM\Administrator (on AD store)
// #define ENABLE_DC_DOWN 1        // Run tests where DC cannot be located


#if defined(ENABLE_LOCAL_ACCOUNT) || defined(ENABLE_NT4_ACCOUNT)
#define ENABLE_NON_DS_ACCOUNT 1
#endif

#if defined(ENABLE_ADMIN_ACCOUNT_XML) || defined(ENABLE_ADMIN_ACCOUNT_AD)
#define ENABLE_ADMIN_ACCOUNT 1
#endif

//
// Global parameters to AzInitialize
//


LPWSTR AzGlTestFile;
BOOLEAN NoInitAllTests = FALSE;
BOOLEAN NoUpdateCache = FALSE;
BOOLEAN Silent = FALSE;

//
// Structure to define an operation to preform
//

typedef struct _OPERATION {

    // The operation
    ULONG Opcode;

// These are generic opcodes that work for all object types
#define AzoGenCreate    0
#define AzoGenOpen      1
#define AzoGenEnum      2
#define AzoGenDelete    3

#define AzoGenMax       50

//
// These are object specific opcodes
//

#define AzoAdm          51
#define AzoAdmDelete    (AzoAdm+AzoGenDelete)

#define AzoApp          100
#define AzoAppCreate    (AzoApp+AzoGenCreate)
#define AzoAppOpen      (AzoApp+AzoGenOpen)
#define AzoAppEnum      (AzoApp+AzoGenEnum)
#define AzoAppDelete    (AzoApp+AzoGenDelete)

#define AzoOp           200
#define AzoOpCreate     (AzoOp+AzoGenCreate)
#define AzoOpOpen       (AzoOp+AzoGenOpen)
#define AzoOpEnum       (AzoOp+AzoGenEnum)
#define AzoOpDelete     (AzoOp+AzoGenDelete)

#define AzoTask         300
#define AzoTaskCreate   (AzoTask+AzoGenCreate)
#define AzoTaskOpen     (AzoTask+AzoGenOpen)
#define AzoTaskEnum     (AzoTask+AzoGenEnum)
#define AzoTaskDelete   (AzoTask+AzoGenDelete)

#define AzoScope        400
#define AzoScopeCreate  (AzoScope+AzoGenCreate)
#define AzoScopeOpen    (AzoScope+AzoGenOpen)
#define AzoScopeEnum    (AzoScope+AzoGenEnum)
#define AzoScopeDelete  (AzoScope+AzoGenDelete)

#define AzoGroup         500
#define AzoGroupCreate   (AzoGroup+AzoGenCreate)
#define AzoGroupOpen     (AzoGroup+AzoGenOpen)
#define AzoGroupEnum     (AzoGroup+AzoGenEnum)
#define AzoGroupDelete   (AzoGroup+AzoGenDelete)

#define AzoRole          600
#define AzoRoleCreate    (AzoRole+AzoGenCreate)
#define AzoRoleOpen      (AzoRole+AzoGenOpen)
#define AzoRoleEnum      (AzoRole+AzoGenEnum)
#define AzoRoleDelete    (AzoRole+AzoGenDelete)

#define AzoCC         800

//
// Real APIs that don't map to the generic APIs
#define AzoInit         1000
#define AzoClose        1001
#define AzoInitCFT      1002    // AzInitContextFromToken
#define AzoAccess       1003
#define AzoGetProp      1004
#define AzoSetProp      1005
#define AzoAddProp      1006
#define AzoRemProp      1007
#define AzoAdmDeleteNoInit 1008 // Same as AdmDelete but don't AzInitialize first
#define AzoUpdateCache  1009

//
// Pseudo opcode for TestLink subroutine
//

#define AzoTl          2000
#define AzoTlCreate    (AzoTl+AzoGenCreate)
#define AzoTlOpen      (AzoTl+AzoGenOpen)
#define AzoTlEnum      (AzoTl+AzoGenEnum)
#define AzoTlDelete    (AzoTl+AzoGenDelete)
#define AzoTlMax       2999

// Opcodes that aren't really API calls
#define AzoSleep        0x0FFFFFFA
#define AzoTestLink     0x0FFFFFFB
#define AzoGoSub        0x0FFFFFFC
#define AzoEcho         0x0FFFFFFD
#define AzoDupHandle    0x0FFFFFFE
#define AzoEndOfList    0x0FFFFFFF

//
// Bits that can be OR'ed into any opcode
//

#define AzoAbort         0x80000000  // Abort instead of commit
#define AzoNoSubmit      0x40000000  // Neither abort nor commit
#define AzoNoUpdateCache 0x20000000  // Don't call AzUpdateCache



    // Input Handle
    PAZ_HANDLE InputHandle;

    // Input Parameter
    LPWSTR Parameter1;

    // Output Handle
    // For AzoAccess, this is an array of operations
    PAZ_HANDLE OutputHandle;

    // Expected result status code
    ULONG ExpectedStatus;

    // List of operations to perform on each enumeration handle
    struct _OPERATION *EnumOperations;

    // Expected result String parameter
    // For AzoAccess, this is an array of results
    LPWSTR ExpectedParameter1;

    // Property ID of Get/SetPropertyId functions
    // For AzoAccess, this is the operation count.
    ULONG PropertyId;

} OPERATION, *POPERATION;

//
// Global handles
//

AZ_HANDLE AdminMgrHandle1;
AZ_HANDLE AdminMgrHandle2;

AZ_HANDLE AppHandle1;
AZ_HANDLE AppHandle2;

AZ_HANDLE OpHandle1;
AZ_HANDLE TaskHandleA;
AZ_HANDLE TaskHandle1;
AZ_HANDLE TaskHandle2;
AZ_HANDLE TaskHandleT;

AZ_HANDLE ScopeHandle1;
AZ_HANDLE ScopeHandle2;

AZ_HANDLE GroupHandleA;
AZ_HANDLE GroupHandleB;
AZ_HANDLE GroupHandle1;
AZ_HANDLE GroupHandle2;
AZ_HANDLE GroupHandleT;

AZ_HANDLE RoleHandleA;
AZ_HANDLE RoleHandle1;
AZ_HANDLE RoleHandle2;

AZ_HANDLE GenParentHandle1;

AZ_HANDLE GenHandle1;
AZ_HANDLE GenHandle2;
AZ_HANDLE GenHandleE;
AZ_HANDLE GenHandleE2;

HANDLE TokenHandle;
AZ_HANDLE CCHandle;
AZ_HANDLE CCHandle2;

//
// Constant property values
//
ULONG Zero = 0;
ULONG Eight = 8;
ULONG EightHundred = 800;
ULONG Nine  = 9;
ULONG FifteenThousand = 15000;
ULONG FiveThousand = 5000;
ULONG FortyFiveThousand = 45000;
ULONG GtBasic = AZ_GROUPTYPE_BASIC;
ULONG GtLdap = AZ_GROUPTYPE_LDAP_QUERY;
LONG AzGlTrue = TRUE;
#define ValidGuid L"47e348af-ff79-41af-8a67-2835d4c417f4"

//
// Various Sid constants
//
typedef struct _SID8 {
   UCHAR Revision;
   UCHAR SubAuthorityCount;
   SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
   ULONG SubAuthority[8];
} SID8, *PISID8;
#define SECURITY_MISC_AUTHORITY       {0,0,0,0,3,0xe8}
SID SidWorld = { 1, 1, SECURITY_WORLD_SID_AUTHORITY, SECURITY_WORLD_RID };
SID SidCreatorOwner = { 1, 1, SECURITY_CREATOR_SID_AUTHORITY, SECURITY_CREATOR_OWNER_RID };
SID SidLocal = { 1, 1, SECURITY_LOCAL_SID_AUTHORITY, SECURITY_LOCAL_RID };
SID Sid1 = { 1, 1, SECURITY_MISC_AUTHORITY, 1 };
SID Sid2 = { 1, 1, SECURITY_MISC_AUTHORITY, 2 };
SID Sid3 = { 1, 1, SECURITY_MISC_AUTHORITY, 3 };
SID Sid4 = { 1, 1, SECURITY_MISC_AUTHORITY, 4 };
SID Sid5 = { 1, 1, SECURITY_MISC_AUTHORITY, 5 };
SID Sid6 = { 1, 1, SECURITY_MISC_AUTHORITY, 6 };
#ifdef ENABLE_CLIFFV_ACCOUNT
SID8 SidOwner = { 1, 5, SECURITY_NT_AUTHORITY, SECURITY_NT_NON_UNIQUE, 397955417, 626881126, 188441444, 2908288 };
#endif // ENABLE_CLIFFV_ACCOUNT
#ifdef ENABLE_ADMIN_ACCOUNT_XML
SID8 SidOwner = { 1, 2, SECURITY_NT_AUTHORITY, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS };
#endif // ENABLE_ADMIN_ACCOUNT_XML
#ifdef ENABLE_ADMIN_ACCOUNT_AD
SID8 SidOwner = { 1, 5, SECURITY_NT_AUTHORITY, SECURITY_NT_NON_UNIQUE, 3421389450, 3242236637, 3934022420, 512 };
#endif // ENABLE_ADMIN_ACCOUNT_AD
#ifdef ENABLE_CHAITU_ACCOUNT
SID8 SidOwner = { 1, 5, SECURITY_NT_AUTHORITY, SECURITY_NT_NON_UNIQUE, 397955417, 626881126, 188441444, 3014042 };
#endif // ENABLE_CHAITU_ACCOUNT

PSID SidWorldOwnerx[] = { &SidWorld, (PSID)&SidOwner };
AZ_SID_ARRAY SidWorldOwnerArray = { 2, SidWorldOwnerx };
PSID SidOwnerx[] = { (PSID)&SidOwner };
AZ_SID_ARRAY SidOwnerArray = { 1, SidOwnerx };
PSID SidWorldx[] = { (PSID)&SidWorld };
AZ_SID_ARRAY SidWorldArray = { 1, SidWorldx };

DWORD SidX[100];
PSID Sid2x[] = { &Sid2 };
AZ_SID_ARRAY Sid2Array = { 1, Sid2x };

PSID Sid3x[] = { &Sid3 };
AZ_SID_ARRAY Sid3Array = { 1, Sid3x };

PSID Sid23x[] = { &Sid2, &Sid3 };
AZ_SID_ARRAY Sid23Array = { 2, Sid23x };

PSID Sid123x[] = { &Sid1, &Sid2, &Sid3 };
AZ_SID_ARRAY Sid123Array = { 3, Sid123x };

PSID Sid123456x[] = { &Sid1, &Sid2, &Sid3, &Sid4, &Sid5, &Sid6 };
AZ_SID_ARRAY Sid123456Array = { 6, Sid123456x };

//
// Generic operations valid for all enumerations
//
//  Requires GenHandleE to already be set
//

// Test double close of enum handle
OPERATION OpAppChildGenEnum1[] = {
    { AzoDupHandle, &GenHandleE,    NULL,        &GenHandleE2, NO_ERROR },
    { AzoClose,     &GenHandleE,    NULL,        NULL,         NO_ERROR },
    { AzoClose,     &GenHandleE,    NULL,        NULL,         ERROR_INVALID_HANDLE },
    { AzoClose,     &GenHandleE2,   NULL,        NULL,         ERROR_INVALID_HANDLE },
    { AzoEndOfList }
};

// General purpose object enum
OPERATION OpAppChildGenEnum2[] = {
    { AzoGetProp,    &GenHandleE,   NULL,        NULL,    NO_ERROR, NULL, NULL, AZ_PROP_NAME },
    { AzoGetProp,    &GenHandleE,   NULL,        NULL,    NO_ERROR, NULL, NULL, AZ_PROP_DESCRIPTION },
    { AzoClose,      &GenHandleE,   NULL,        NULL,    NO_ERROR },
    { AzoEndOfList }
};

//
// Generic operations that work on *ALL* objects
//
//  Requires GenParentHandle1 to already be set
//

OPERATION OpGen[] = {
    { AzoEcho, NULL, L"Gen object test" },
    { AzoGenCreate,  &GenParentHandle1,L"|",        &GenHandle1,      ERROR_INVALID_NAME },
    { AzoGenCreate,  &GenParentHandle1,L"Name1",    &GenHandle1,      NO_ERROR },
    { AzoDupHandle,  &GenHandle1,      NULL,        &GenHandle2,      NO_ERROR },
    { AzoClose,      &GenHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoClose,      &GenHandle2,      NULL,        NULL,             ERROR_INVALID_HANDLE },
    { AzoGenEnum,    &GenHandle1,      NULL,        &GenHandleE,      ERROR_INVALID_HANDLE },
    { AzoGenEnum,    &GenParentHandle1,NULL,        &GenHandleE,      NO_ERROR, OpAppChildGenEnum1 },
    { AzoGenEnum,    &GenParentHandle1,NULL,        &GenHandleE,      NO_ERROR, OpAppChildGenEnum2 },
    { AzoGenCreate,  &GenParentHandle1,L"Name2",    &GenHandle2,      NO_ERROR },
    { AzoGenEnum,    &GenParentHandle1,NULL,        &GenHandleE,      NO_ERROR, OpAppChildGenEnum2 },
    { AzoClose,      &GenHandle2,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Delete an object and make sure it doesn't get enumerated" },
    { AzoGenCreate,  &GenParentHandle1,L"Name3",    &GenHandle2,      NO_ERROR },
    { AzoGenDelete,  &GenParentHandle1,L"Name3",    NULL,             NO_ERROR },
    { AzoClose,      &GenHandle2,      NULL,        NULL,             NO_ERROR },
    { AzoGenEnum,    &GenParentHandle1,NULL,        &GenHandleE,      NO_ERROR, OpAppChildGenEnum2 },

    { AzoEcho, NULL, L"Create an object whose name equals that of a deleted object" },
    { AzoGenCreate,  &GenParentHandle1,L"Name3",    &GenHandle2,      NO_ERROR },
    { AzoClose,      &GenHandle2,      NULL,        NULL,             NO_ERROR },
    { AzoGenEnum,    &GenParentHandle1,NULL,        &GenHandleE,      NO_ERROR, OpAppChildGenEnum2 },

    { AzoEcho, NULL, L"Delete an object that isn't on the tail end of the enum list" },
    { AzoGenDelete,  &GenParentHandle1,L"Name2",    NULL,             NO_ERROR },
    { AzoGenEnum,    &GenParentHandle1,NULL,        &GenHandleE,      NO_ERROR, OpAppChildGenEnum2 },

    { AzoEcho, NULL, L"Basic get/set property tests" },
    { AzoGenCreate,  &GenParentHandle1,L"Name4",    &GenHandle1,      NO_ERROR },
    { AzoGetProp,    &GenHandle1,      NULL,        NULL,             NO_ERROR, NULL, L"Name4",     AZ_PROP_NAME },
    { AzoSetProp,    &GenHandle1,      L"|",        NULL,             ERROR_INVALID_NAME, NULL, NULL, AZ_PROP_NAME },
    { AzoGetProp,    &GenHandle1,      NULL,        NULL,             NO_ERROR, NULL, L"Name4",     AZ_PROP_NAME },
    { AzoSetProp,    &GenHandle1,      L"Name4",    NULL,             ERROR_ALREADY_EXISTS, NULL, NULL, AZ_PROP_NAME },
    { AzoGetProp,    &GenHandle1,      NULL,        NULL,             NO_ERROR, NULL, L"Name4",     AZ_PROP_NAME },
    { AzoSetProp,    &GenHandle1,      L"Name3",    NULL,             ERROR_ALREADY_EXISTS, NULL, NULL, AZ_PROP_NAME },
    { AzoGetProp,    &GenHandle1,      NULL,        NULL,             NO_ERROR, NULL, L"Name4",     AZ_PROP_NAME },
    { AzoGetProp,    &GenHandle1,      NULL,        NULL,             NO_ERROR, NULL, L"",          AZ_PROP_DESCRIPTION },
    { AzoSetProp,    &GenHandle1,      L"WasName4", NULL,             NO_ERROR, NULL, NULL,         AZ_PROP_NAME },
    { AzoSetProp,    &GenHandle1,      L"Nam4 Desc",NULL,             NO_ERROR, NULL, NULL,         AZ_PROP_DESCRIPTION },
    { AzoGetProp,    &GenHandle1,      NULL,        NULL,             NO_ERROR, NULL, L"WasName4",  AZ_PROP_NAME },
    { AzoGetProp,    &GenHandle1,      NULL,        NULL,             NO_ERROR, NULL, L"Nam4 Desc", AZ_PROP_DESCRIPTION },
    { AzoGenEnum,    &GenParentHandle1,NULL,        &GenHandleE,      NO_ERROR, OpAppChildGenEnum2 },
    { AzoClose,      &GenHandle1,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure a newly created object is writable" },
    { AzoGenCreate,  &GenParentHandle1,L"Name5",    &GenHandle2,      NO_ERROR },
    { AzoGetProp,    &GenHandle2,      NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&AzGlTrue,  AZ_PROP_WRITABLE },
    { AzoClose,      &GenHandle2,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Open test" },
    { AzoGenOpen,    &GenParentHandle1,L"Name1",    &GenHandle1,      NO_ERROR },
    { AzoGetProp,    &GenHandle1,      NULL,        NULL,             NO_ERROR, NULL, L"Name1",     AZ_PROP_NAME },
    { AzoClose,      &GenHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoGenOpen,    &GenParentHandle1,L"NameBad",  &GenHandle1,      ERROR_NOT_FOUND },

    { AzoEndOfList }
};

//
// Operations specific to admin manager objects
//
OPERATION OpAdm[] = {
    { AzoEcho, NULL, L"Admin Manager specific operations" },
    { AzoInit,         NULL,             NULL,      &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },

    { AzoEcho, NULL, L"Ensure the admin manager object is marked writable" },
    { AzoGetProp,    &AdminMgrHandle1,   NULL,      NULL,             NO_ERROR, NULL, (LPWSTR)&AzGlTrue,  AZ_PROP_WRITABLE },

    { AzoEcho, NULL, L"Set description on Admin Manager" },
    { AzoGetProp,    &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR, NULL, L"",                     AZ_PROP_DESCRIPTION },
    { AzoSetProp,    &AdminMgrHandle1,     L"Adm Desc", NULL,             NO_ERROR, NULL, NULL,                    AZ_PROP_DESCRIPTION },
    { AzoGetProp,    &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR, NULL, L"Adm Desc",             AZ_PROP_DESCRIPTION },

    { AzoEcho, NULL, L"Set Application Data on AdminManager" },
    { AzoGetProp,    &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR, NULL, L"",                     AZ_PROP_APPLICATION_DATA },
    { AzoSetProp,    &AdminMgrHandle1,     L"Adm Application Data", NULL, NO_ERROR, NULL, NULL,                    AZ_PROP_APPLICATION_DATA },
    { AzoGetProp,    &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR, NULL, L"Adm Application Data", AZ_PROP_APPLICATION_DATA },

    { AzoGetProp,    &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&FifteenThousand, AZ_PROP_ADMIN_DOMAIN_TIMEOUT },
    { AzoSetProp,    &AdminMgrHandle1,     (LPWSTR)&EightHundred,NULL,     NO_ERROR, NULL, NULL,                    AZ_PROP_ADMIN_DOMAIN_TIMEOUT },
    { AzoGetProp,    &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&EightHundred,    AZ_PROP_ADMIN_DOMAIN_TIMEOUT },

    { AzoAdmDelete,  &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Test closing admin manager with other handle open" },
    { AzoInit,      NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate, &AdminMgrHandle1, L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoClose,     &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,     &AppHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoInit,      NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, 0 },

    { AzoEcho, NULL, L"Test Setting the list of admins" },
    { AzoGetProp,   &AdminMgrHandle1, NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&SidOwnerArray,  AZ_PROP_POLICY_ADMINS },
    { AzoAddProp,   &AdminMgrHandle1, (LPWSTR)&SidCreatorOwner, NULL, ERROR_INVALID_PARAMETER, NULL, NULL,                    AZ_PROP_POLICY_ADMINS },
    { AzoAddProp,   &AdminMgrHandle1, (LPWSTR)&SidWorld, NULL,        NO_ERROR, NULL, NULL,                    AZ_PROP_POLICY_ADMINS },
    { AzoGetProp,   &AdminMgrHandle1, NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&SidWorldOwnerArray,  AZ_PROP_POLICY_ADMINS },
    { AzoRemProp,   &AdminMgrHandle1, (LPWSTR)&SidOwner, NULL,        NO_ERROR, NULL, NULL,                    AZ_PROP_POLICY_ADMINS },
    { AzoGetProp,   &AdminMgrHandle1, NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&SidWorldArray,  AZ_PROP_POLICY_ADMINS },
    { AzoRemProp,   &AdminMgrHandle1, (LPWSTR)&SidWorld, NULL,        NO_ERROR, NULL, NULL,                    AZ_PROP_POLICY_ADMINS },
    { AzoGetProp,   &AdminMgrHandle1, NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&SidOwnerArray,  AZ_PROP_POLICY_ADMINS },


    { AzoAdmDelete, &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,     &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },

    { AzoEndOfList }
};


//
// Generic operations valid for all children of "admin manager"
//

OPERATION OpAdmChildGen[] = {
    { AzoEcho, NULL, L"Admin Manager generic Child object test" },
    { AzoInit,       NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },

    // Do a bunch of stuff not specific to application children
    { AzoDupHandle,  &AdminMgrHandle1, NULL,        &GenParentHandle1,NO_ERROR },
    { AzoGoSub,      NULL,             NULL,        NULL,             NO_ERROR, OpGen },

    { AzoAdmDelete,  &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpAdmChildGenDupName[] = {
    { AzoEcho, NULL, L"Test creating two objects with the same name" },
    { AzoInit,       NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoGenCreate,  &AdminMgrHandle1, L"Name1",    &GenHandle1,      NO_ERROR },
    { AzoGenCreate,  &AdminMgrHandle1, L"Name1",    &GenHandle2,      ERROR_ALREADY_EXISTS },
    { AzoClose,      &GenHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,  &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};


//
// Generic operations valid for all children of "application"
//

OPERATION OpAppChildGen[] = {
    { AzoEcho, NULL, L"Application generic Child object test" },
    { AzoInit,       NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,  &AdminMgrHandle1, L"MyApp",    &AppHandle1,      NO_ERROR },

    // Do a bunch of stuff not specific to application children
    { AzoDupHandle,  &AppHandle1,      NULL,        &GenParentHandle1,NO_ERROR },
    { AzoGoSub,      NULL,             NULL,        NULL,             NO_ERROR, OpGen },

    { AzoClose,      &AppHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,  &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpAppChildGenDupName[] = {
    { AzoEcho, NULL, L"Test creating two objects with the same name" },
    { AzoInit,       NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,  &AdminMgrHandle1, L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoAppCreate,  &AdminMgrHandle1, L"MyApp",    &AppHandle2,      ERROR_ALREADY_EXISTS },
    { AzoGenCreate,  &AppHandle1,      L"Name1",    &GenHandle1,      NO_ERROR },
    { AzoGenCreate,  &AppHandle1,      L"Name1",    &GenHandle2,      ERROR_ALREADY_EXISTS },
    { AzoClose,      &GenHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AppHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,  &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpAppChildGenLeak[] = {
    { AzoEcho, NULL, L"Test leaking a handle" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1, L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoClose,        &AppHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};


//
// Generic operations valid for all children of "scope"
//

OPERATION OpScopeChildGen[] = {
    { AzoEcho, NULL, L"Scope generic Child object test" },
    { AzoInit,       NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,  &AdminMgrHandle1, L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoScopeCreate,&AppHandle1,      L"Scope 1",  &ScopeHandle1,    NO_ERROR },

    // Do a bunch of stuff not specific to scope children
    { AzoDupHandle,  &ScopeHandle1,    NULL,        &GenParentHandle1,NO_ERROR },
    { AzoGoSub,      NULL,             NULL,        NULL,             NO_ERROR, OpGen },

    { AzoClose,      &ScopeHandle1,    NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AppHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,  &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpScopeChildGenDupName[] = {
    { AzoEcho, NULL, L"Test creating two objects with the same name" },
    { AzoInit,       NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,  &AdminMgrHandle1, L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoScopeCreate,&AppHandle1,      L"Scope 1",  &ScopeHandle1,    NO_ERROR },

    { AzoGenCreate,  &ScopeHandle1,    L"Name1",    &GenHandle1,      NO_ERROR },
    { AzoGenCreate,  &ScopeHandle1,    L"Name1",    &GenHandle2,      ERROR_ALREADY_EXISTS },
    { AzoClose,      &GenHandle1,      NULL,        NULL,             NO_ERROR },

    { AzoClose,      &ScopeHandle1,    NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AppHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,  &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,      &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

//
// Specific tests for application objects
//

OPERATION OpApplication[] = {
    { AzoEcho, NULL, L"Application object specific tests" },
    { AzoInit,      NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate, &AdminMgrHandle1, L"MyApp",    &AppHandle1,      NO_ERROR },

    { AzoEcho, NULL, L"Ensure CLSID can be set" },
    { AzoGetProp,    &AppHandle1,       NULL,        NULL,             NO_ERROR, NULL, NULL, AZ_PROP_APPLICATION_AUTHZ_INTERFACE_CLSID },
    { AzoSetProp,    &AppHandle1,       L"Rule1",    NULL,             RPC_S_INVALID_STRING_UUID, NULL, NULL,        AZ_PROP_APPLICATION_AUTHZ_INTERFACE_CLSID },
    { AzoSetProp,    &AppHandle1,       ValidGuid,   NULL,             NO_ERROR, NULL, NULL,        AZ_PROP_APPLICATION_AUTHZ_INTERFACE_CLSID },
    { AzoGetProp,    &AppHandle1,       NULL,        NULL,             NO_ERROR, NULL, ValidGuid,   AZ_PROP_APPLICATION_AUTHZ_INTERFACE_CLSID },
    { AzoSetProp,    &AppHandle1,       NULL,        NULL,             NO_ERROR, NULL, NULL,        AZ_PROP_APPLICATION_AUTHZ_INTERFACE_CLSID },
    { AzoGetProp,    &AppHandle1,       NULL,        NULL,             NO_ERROR, NULL, NULL, AZ_PROP_APPLICATION_AUTHZ_INTERFACE_CLSID },

    { AzoEcho, NULL, L"Ensure app version can be set" },
    { AzoGetProp,    &AppHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"",         AZ_PROP_APPLICATION_VERSION },
    { AzoSetProp,    &AppHandle1,       L"2160.5",   NULL,             NO_ERROR, NULL, NULL,        AZ_PROP_APPLICATION_VERSION },
    { AzoGetProp,    &AppHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"2160.5",   AZ_PROP_APPLICATION_VERSION },

    { AzoEcho, NULL, L"Ensure app data can be set" },
    { AzoGetProp,    &AppHandle1,       NULL,                      NULL,             NO_ERROR, NULL, L"",                       AZ_PROP_APPLICATION_DATA },
    { AzoSetProp,    &AppHandle1,       L"App Application Data",   NULL,             NO_ERROR, NULL, NULL,                      AZ_PROP_APPLICATION_DATA },
    { AzoGetProp,    &AppHandle1,       NULL,                      NULL,             NO_ERROR, NULL, L"App Application Data",   AZ_PROP_APPLICATION_DATA },

    { AzoClose,     &AppHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete, &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,     &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};




//
// Specific tests for Operation objects
//

OPERATION OpOperation[] = {
    { AzoEcho, NULL, L"Operation object specific tests" },
    { AzoInit,      NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate, &AdminMgrHandle1, L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoOpCreate,  &AppHandle1,      L"Oper 1",   &OpHandle1,       NO_ERROR },
    { AzoGetProp,    &OpHandle1,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Zero,  AZ_PROP_OPERATION_ID },
    { AzoSetProp,    &OpHandle1,    (LPWSTR)&Eight, NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_OPERATION_ID },
    { AzoGetProp,    &OpHandle1,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Eight, AZ_PROP_OPERATION_ID },

    { AzoEcho, NULL, L"Ensure operation Application data can be set" },
    { AzoGetProp,    &OpHandle1,       NULL,                   NULL,             NO_ERROR, NULL, L"",                    AZ_PROP_APPLICATION_DATA },
    { AzoSetProp,    &OpHandle1,       L"Op Application Data", NULL,             NO_ERROR, NULL, NULL,                   AZ_PROP_APPLICATION_DATA },
    { AzoGetProp,    &OpHandle1,       NULL,                   NULL,             NO_ERROR, NULL, L"Op Application Data", AZ_PROP_APPLICATION_DATA },
    { AzoClose,     &OpHandle1,       NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure an operation ID cannot be reused" },
    { AzoOpCreate,  &AppHandle1,      L"Oper 2",   &OpHandle1,       NO_ERROR },
    { AzoSetProp,    &OpHandle1,    (LPWSTR)&Eight, NULL,            ERROR_ALREADY_EXISTS, NULL, NULL,           AZ_PROP_OPERATION_ID },
    { AzoClose,     &OpHandle1,       NULL,        NULL,             NO_ERROR },

    { AzoClose,     &AppHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete, &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoClose,     &AdminMgrHandle1, NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};



//
// Generic test of the ability of one object to link to another
//  AzoTestLink is the only opcode that can link to this subroutine of commands
//

AZ_STRING_ARRAY EmptyStringArray = { 0, NULL };

ULONG TestLinkOpcodeOffset;
ULONG TestLinkPropId;
AZ_HANDLE TestLinkHandleP;
AZ_HANDLE TestLinkHandleA;
WCHAR TestLinkObjectName[1000];

LPWSTR Op1x[] = { L"Op 1" };
AZ_STRING_ARRAY Op1 = { 1, Op1x };

LPWSTR Op12x[] = { L"Op 1", L"Op 2" };
AZ_STRING_ARRAY Op12 = { 2, Op12x };

LPWSTR Op24x[] = { L"Op 2", L"Op 4" };
AZ_STRING_ARRAY Op24 = { 2, Op24x };

LPWSTR Object2x[] = { L"Object 2" };
AZ_STRING_ARRAY Object2 = { 1, Object2x };

LPWSTR Object3x[] = { L"Object 3" };
AZ_STRING_ARRAY Object3 = { 1, Object3x };

LPWSTR Object23x[] = { L"Object 2", L"Object 3" };
AZ_STRING_ARRAY Object23 = { 2, Object23x };

LPWSTR Object123x[] = { L"Object 1", L"Object 2", L"Object 3" };
AZ_STRING_ARRAY Object123 = { 3, Object123x };

LPWSTR Object123456x[] = { L"Object 1", L"Object 2", L"Object 3", L"Object 4", L"Object 5", L"Object 6" };
AZ_STRING_ARRAY Object123456 = { 6, Object123456x };

OPERATION OpTestLink[] = {
    { AzoEcho, NULL,  L"Create some objects to link the object to" },
    { AzoTlCreate,    &TestLinkHandleP,        L"Object 1",   &OpHandle1,       NO_ERROR },
    { AzoClose,       &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoTlCreate,    &TestLinkHandleP,        L"Object 2",   &OpHandle1,       NO_ERROR },
    { AzoClose,       &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoTlCreate,    &TestLinkHandleP,        L"Object 3",   &OpHandle1,       NO_ERROR },
    { AzoClose,       &OpHandle1,         NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL,  L"Reference an object that doesn't exist" },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&EmptyStringArray, 1 },
    { AzoSetProp,    &TestLinkHandleA,       L"random",   NULL,             ERROR_INVALID_PARAMETER, NULL, NULL,       1 },
    { AzoAddProp,    &TestLinkHandleA,       L"random",   NULL,             ERROR_NOT_FOUND, NULL, NULL,               1 },

    { AzoEcho, NULL,  L"Add and remove several objects" },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 2",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Object2,            1 },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 3",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Object23,           1 },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 1",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Object123,          1 },
    { AzoRemProp,    &TestLinkHandleA,       L"Object 1",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Object23,           1 },
    { AzoRemProp,    &TestLinkHandleA,       L"Object 2",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Object3,            1 },

#if 0
    // This test has a couple problems.
    //  It assumes that the linked-to and linked-from objects have the same parents
    //  It assumes that an Open returns the same handle value as a previous close
    { AzoEcho, NULL,  L"Ensure the reference is still there after a close" },
    { AzoClose,       &TestLinkHandleA,       NULL,        NULL,             NO_ERROR },
    { AzoGenOpen,    &TestLinkHandleP,   TestLinkObjectName,  &TestLinkHandleA,     NO_ERROR },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Object3,            1 },
#endif // 0

    { AzoEcho, NULL,  L"Add an item that already exists" },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 3",   NULL,             ERROR_ALREADY_EXISTS, NULL, NULL,          1 },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Object3,            1 },
    { AzoRemProp,    &TestLinkHandleA,       L"Object 3",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&EmptyStringArray, 1 },

    { AzoEcho, NULL,  L"Try more than 4 since reference buckets come in multiples of 4" },
    { AzoTlCreate,    &TestLinkHandleP,        L"Object 4",   &OpHandle1,       NO_ERROR },
    { AzoClose,       &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoTlCreate,    &TestLinkHandleP,        L"Object 5",   &OpHandle1,       NO_ERROR },
    { AzoClose,       &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoTlCreate,    &TestLinkHandleP,        L"Object 6",   &OpHandle1,       NO_ERROR },
    { AzoClose,       &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 1",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 4",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 2",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 5",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 3",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,       L"Object 6",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Object123456,       1 },

    { AzoTlDelete, &TestLinkHandleP,       L"Object 1",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoTlDelete|AzoNoUpdateCache, &TestLinkHandleP,       L"Object 4",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoTlDelete|AzoNoUpdateCache, &TestLinkHandleP,       L"Object 2",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoTlDelete, &TestLinkHandleP,       L"Object 5",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoTlDelete, &TestLinkHandleP,       L"Object 3",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoTlDelete, &TestLinkHandleP,       L"Object 6",   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoEndOfList }
};

//
// Generic test of the ability of an object to link to a sid
//  AzoTestLink is the only opcode that can link to this subroutine of commands
//

OPERATION OpTestSid[] = {
    { AzoEcho, NULL,  L"Add and remove several links to sids" },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid2,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,   NULL,            NULL,             NO_ERROR, NULL, (LPWSTR)&Sid2Array,            1 },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid3,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,   NULL,            NULL,             NO_ERROR, NULL, (LPWSTR)&Sid23Array,           1 },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid1,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,   NULL,            NULL,             NO_ERROR, NULL, (LPWSTR)&Sid123Array,          1 },
    { AzoRemProp,    &TestLinkHandleA,   (LPWSTR)&Sid1,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,   NULL,            NULL,             NO_ERROR, NULL, (LPWSTR)&Sid23Array,           1 },
    { AzoRemProp,    &TestLinkHandleA,   (LPWSTR)&Sid2,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,   NULL,            NULL,             NO_ERROR, NULL, (LPWSTR)&Sid3Array,            1 },

    { AzoEcho, NULL,  L"Add a link that already exists" },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid3,   NULL,             ERROR_ALREADY_EXISTS, NULL, NULL,          1 },
    { AzoGetProp,    &TestLinkHandleA,   NULL,            NULL,             NO_ERROR, NULL, (LPWSTR)&Sid3Array,            1 },
    { AzoRemProp,    &TestLinkHandleA,   (LPWSTR)&Sid3,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,   NULL,            NULL,             NO_ERROR, NULL, (LPWSTR)&EmptyStringArray, 1 },

    { AzoEcho, NULL,  L"Try more than 4 since reference buckets come in multiples of 4" },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid1,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid4,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid2,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid5,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid3,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoAddProp,    &TestLinkHandleA,   (LPWSTR)&Sid6,   NULL,             NO_ERROR, NULL, NULL,                      1 },
    { AzoGetProp,    &TestLinkHandleA,   NULL,            NULL,             NO_ERROR, NULL, (LPWSTR)&Sid123456Array,       1 },
    { AzoEndOfList }
};

//
// Specific tests for Task objects
//

//
// Task object tests that are agnostic about the parent object
//  Requires GenParentHandle1 to already be set
//
OPERATION OpGenTask[] = {
    { AzoEcho, NULL, L"Task object specific tests" },

    { AzoTaskCreate,  &GenParentHandle1,  L"Task 1",   &TaskHandle1,     NO_ERROR },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"",         AZ_PROP_TASK_BIZRULE },

    { AzoEcho, NULL, L"Set the bizrule before the langauge" },
    { AzoSetProp,    &TaskHandle1,       L"While True\nWend", NULL,     ERROR_INVALID_PARAMETER, NULL, NULL, AZ_PROP_TASK_BIZRULE },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"",         AZ_PROP_TASK_BIZRULE },

    { AzoEcho, NULL,  L"Try an invalid language" },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"",         AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoSetProp,    &TaskHandle1,       L"LANG1",    NULL,             ERROR_INVALID_PARAMETER, NULL, NULL, AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"",         AZ_PROP_TASK_BIZRULE_LANGUAGE },

    { AzoEcho, NULL,  L"Try the valid languages" },
    { AzoSetProp,    &TaskHandle1,       L"Jscript",  NULL,             NO_ERROR, NULL, L"",         AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"Jscript",  AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoSetProp,    &TaskHandle1,       L"VBScript", NULL,             NO_ERROR, NULL, NULL,        AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"VBScript", AZ_PROP_TASK_BIZRULE_LANGUAGE },

    { AzoEcho, NULL, L"Set a syntactically invalid bizrule" },
    { AzoSetProp,    &TaskHandle1,       L"Rule1,",   NULL,             OLESCRIPT_E_SYNTAX, NULL, NULL,        AZ_PROP_TASK_BIZRULE },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"",         AZ_PROP_TASK_BIZRULE },

    { AzoEcho, NULL, L"Set a syntactically valid bizrule" },
    { AzoSetProp,    &TaskHandle1,       L"While True\nWend", NULL,     NO_ERROR, NULL, NULL, AZ_PROP_TASK_BIZRULE },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"While True\nWend", AZ_PROP_TASK_BIZRULE },

    { AzoEcho, NULL,  L"Try bizrule path" },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"",         AZ_PROP_TASK_BIZRULE_IMPORTED_PATH },
    { AzoSetProp,    &TaskHandle1,       L"c:\\temp", NULL,             NO_ERROR, NULL, NULL,        AZ_PROP_TASK_BIZRULE_IMPORTED_PATH },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"c:\\temp", AZ_PROP_TASK_BIZRULE_IMPORTED_PATH },


    { AzoEcho, NULL,  L"Try Task application data" },
    { AzoGetProp,    &TaskHandle1,       NULL,                     NULL,             NO_ERROR, NULL, L"",                      AZ_PROP_APPLICATION_DATA },
    { AzoSetProp,    &TaskHandle1,       L"Task Application Data", NULL,             NO_ERROR, NULL, NULL,                     AZ_PROP_APPLICATION_DATA },
    { AzoGetProp,    &TaskHandle1,       NULL,                     NULL,             NO_ERROR, NULL, L"Task Application Data", AZ_PROP_APPLICATION_DATA },


    { AzoTestLink,    &GenParentHandle1,  (LPWSTR)"Task", &TaskHandle1,     AzoTask, OpTestLink, L"Task 1", AZ_PROP_TASK_TASKS },

    { AzoEcho, NULL,  L"Reference ourself" },
    { AzoGetProp,    &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&EmptyStringArray, AZ_PROP_TASK_TASKS },
    { AzoAddProp,    &TaskHandle1,       L"Task 1",   NULL,             ERROR_DS_LOOP_DETECT, NULL, NULL,          AZ_PROP_TASK_TASKS },

    { AzoEcho, NULL, L"Test loops" },
    { AzoTaskCreate,  &GenParentHandle1,  L"Task 2",   &TaskHandle2,     NO_ERROR },
    { AzoAddProp,    &TaskHandle1,       L"Task 2",   NULL,             NO_ERROR, NULL, NULL,               AZ_PROP_TASK_TASKS },
    { AzoAddProp,    &TaskHandle2,       L"Task 1",   NULL,             ERROR_DS_LOOP_DETECT, NULL, NULL,               AZ_PROP_TASK_TASKS },
    { AzoRemProp,    &TaskHandle1,       L"Task 2",   NULL,             NO_ERROR, NULL, NULL,               AZ_PROP_TASK_TASKS },

    { AzoClose,       &TaskHandle2,       NULL,        NULL,             NO_ERROR },
    { AzoClose,       &TaskHandle1,       NULL,        NULL,             NO_ERROR },

    { AzoEndOfList }
};

OPERATION OpAppTask[] = {
    { AzoEcho, NULL, L"Task object specific tests" },
    { AzoInit,        NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,   &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },

    // Do a bunch of stuff not specific to application children
    { AzoDupHandle,    &AppHandle1,        NULL,        &GenParentHandle1,NO_ERROR },
    { AzoGoSub,        NULL,               NULL,        NULL,             NO_ERROR, OpGenTask },

    { AzoEcho, NULL, L"Test linking task to operations." },
    { AzoTaskCreate,  &AppHandle1,         L"Task Y",   &TaskHandle1,     NO_ERROR },
    { AzoTestLink,    &AppHandle1, (LPWSTR)"Operation", &TaskHandle1,     AzoOp, OpTestLink, L"Task Y", AZ_PROP_TASK_OPERATIONS },

    { AzoClose,       &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoClose,       &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,   &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,       &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

// Tests for Tasks that are children of a scope
OPERATION OpScopeTask[] = {
    { AzoEcho, NULL, L"Task objects that are children of a scope" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,        L"Scope 1",  &ScopeHandle1,    NO_ERROR },

    // Do a bunch of stuff not specific to scope children
    { AzoDupHandle,    &ScopeHandle1,      NULL,        &GenParentHandle1,NO_ERROR },
    { AzoGoSub,        NULL,               NULL,        NULL,             NO_ERROR, OpGenTask },

    { AzoEcho, NULL, L"Test linking task to operations." },
    { AzoTaskCreate,  &ScopeHandle1,       L"Task X",   &TaskHandle1,     NO_ERROR },
    { AzoTestLink,    &AppHandle1, (LPWSTR)"Operation", &TaskHandle1,     AzoOp, OpTestLink, L"Task X", AZ_PROP_TASK_OPERATIONS },

    { AzoEcho, NULL, L"Test linking scope task to app tasks." },
    { AzoTestLink,    &AppHandle1, (LPWSTR)"Task", &TaskHandle1,     AzoTask, OpTestLink, L"Task X", AZ_PROP_TASK_TASKS },

    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

//
// Specific tests for Group objects
//

//
// Group object tests that are agnostic about the parent object
//  Requires GenParentHandle1 to already be set
//
OPERATION OpGenGroup[] = {
    { AzoEcho, NULL, L"Group object specific tests" },

    { AzoGroupCreate,  &GenParentHandle1,   L"Group A",   &GroupHandleA,    NO_ERROR },
    { AzoGroupCreate,  &GenParentHandle1,   L"Group B",   &GroupHandleB,    NO_ERROR },

    { AzoEcho, NULL, L"Create some groups to link the group to" },
    { AzoGroupCreate,  &GenParentHandle1,   L"Group 1",   &GroupHandle1,    NO_ERROR },
    { AzoClose,        &GroupHandle1,       NULL,         NULL,             NO_ERROR },
    { AzoGroupCreate,  &GenParentHandle1,   L"Group 2",   &GroupHandle1,    NO_ERROR },
    { AzoClose,        &GroupHandle1,       NULL,         NULL,             NO_ERROR },
    { AzoGroupCreate,  &GenParentHandle1,   L"Group 3",   &GroupHandle1,    NO_ERROR },
    { AzoClose,        &GroupHandle1,       NULL,         NULL,             NO_ERROR },

    { AzoEcho, NULL,  L"Set group type to an invalid value" },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&Eight,NULL,            ERROR_INVALID_PARAMETER, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtBasic,NULL,            NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },

    { AzoEcho, NULL,  L"Reference ourself" },
    { AzoGetProp,    &GroupHandleA,       NULL,         NULL,             NO_ERROR, NULL, (LPWSTR)&EmptyStringArray, AZ_PROP_GROUP_APP_MEMBERS },
    { AzoGetProp,    &GroupHandleA,       NULL,         NULL,             NO_ERROR, NULL, (LPWSTR)&EmptyStringArray, AZ_PROP_GROUP_MEMBERS },
    { AzoAddProp,    &GroupHandleA,       L"Group A",   NULL,             ERROR_DS_LOOP_DETECT, NULL, NULL,               AZ_PROP_GROUP_APP_MEMBERS },

    { AzoTestLink,     &GenParentHandle1,   (LPWSTR)"Group", &GroupHandleA, AzoGroup, OpTestLink, L"Group A", AZ_PROP_GROUP_APP_MEMBERS },

    { AzoTestLink,     &GenParentHandle1,   (LPWSTR)"Sid", &GroupHandleA, AzoGroup, OpTestSid, L"Group A", AZ_PROP_GROUP_MEMBERS },

    { AzoEcho, NULL,  L"Same as above, but for the non-members attribute" },
    { AzoGetProp,    &GroupHandleA,       NULL,         NULL,             NO_ERROR, NULL, (LPWSTR)&EmptyStringArray, AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoGetProp,    &GroupHandleA,       NULL,         NULL,             NO_ERROR, NULL, (LPWSTR)&EmptyStringArray, AZ_PROP_GROUP_NON_MEMBERS },
    { AzoAddProp,    &GroupHandleA,       L"Group A",   NULL,             ERROR_DS_LOOP_DETECT, NULL, NULL,       AZ_PROP_GROUP_APP_NON_MEMBERS },

    { AzoTestLink,     &GenParentHandle1,   (LPWSTR)"Group", &GroupHandleA, AzoGroup, OpTestLink, L"Group A", AZ_PROP_GROUP_APP_NON_MEMBERS },

    { AzoTestLink,     &GenParentHandle1,   (LPWSTR)"Sid", &GroupHandleA, AzoGroup, OpTestSid, L"Group A", AZ_PROP_GROUP_NON_MEMBERS },

    { AzoEcho, NULL,  L"Set LdapQuery string on a basic group" },
    { AzoGetProp,    &GroupHandleA,       NULL,        NULL,             NO_ERROR, NULL, L"", AZ_PROP_GROUP_LDAP_QUERY },
    { AzoSetProp,    &GroupHandleA,       L"TheQuery", NULL,             ERROR_INVALID_PARAMETER, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtLdap,NULL,          ERROR_INVALID_PARAMETER, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoSetProp,    &GroupHandleA,       L"TheQuery", NULL,             ERROR_INVALID_PARAMETER, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
    { AzoGetProp,    &GroupHandleA,       NULL,        NULL,             NO_ERROR, NULL, L"", AZ_PROP_GROUP_LDAP_QUERY },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtBasic,NULL,           NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoSetProp,    &GroupHandleA,       L"TheQuery", NULL,             ERROR_INVALID_PARAMETER, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
    { AzoSetProp,    &GroupHandleA,       L"",         NULL,             NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },

    { AzoEcho, NULL,  L"Set LdapQuery string on an ldap query group" },
    { AzoGetProp,    &GroupHandleB,       NULL,        NULL,             NO_ERROR, NULL, L"", AZ_PROP_GROUP_LDAP_QUERY },
    { AzoSetProp,    &GroupHandleB,       L"TheQuery", NULL,             ERROR_INVALID_PARAMETER, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
    { AzoSetProp,    &GroupHandleB,       (LPWSTR)&GtLdap,NULL,          NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoSetProp,    &GroupHandleB,       L"TheQuery", NULL,             NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
    { AzoGetProp,    &GroupHandleB,       NULL,        NULL,             NO_ERROR, NULL, L"TheQuery", AZ_PROP_GROUP_LDAP_QUERY },
    { AzoSetProp,    &GroupHandleB,       (LPWSTR)&GtBasic,NULL,           ERROR_INVALID_PARAMETER, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoGetProp,    &GroupHandleB,       NULL,        NULL,             NO_ERROR, NULL, L"TheQuery", AZ_PROP_GROUP_LDAP_QUERY },
    { AzoSetProp,    &GroupHandleB,       L"",         NULL,             NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },

    { AzoEcho, NULL, L"Test loops" },
    { AzoSetProp,    &GroupHandleB,       (LPWSTR)&GtBasic,NULL,            NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoAddProp,    &GroupHandleA,       L"Group B",   NULL,             NO_ERROR, NULL, NULL,               AZ_PROP_GROUP_APP_MEMBERS },
    { AzoAddProp,    &GroupHandleB,       L"Group A",   NULL,             ERROR_DS_LOOP_DETECT, NULL, NULL,               AZ_PROP_GROUP_APP_MEMBERS },
    { AzoAddProp,    &GroupHandleA,       L"Group B",   NULL,             NO_ERROR, NULL, NULL,               AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoAddProp,    &GroupHandleB,       L"Group A",   NULL,             ERROR_DS_LOOP_DETECT, NULL, NULL,               AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoRemProp,    &GroupHandleA,       L"Group B",   NULL,             NO_ERROR, NULL, NULL,               AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoRemProp,    &GroupHandleA,       L"Group B",   NULL,             NO_ERROR, NULL, NULL,               AZ_PROP_GROUP_APP_MEMBERS },

    { AzoClose,        &GroupHandleB,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &GroupHandleA,       NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

// Tests for groups that are children of an admin manager
OPERATION OpAdmGroup[] = {
    { AzoEcho, NULL, L"Group objects that are children of an admin manager" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },

    // Do a bunch of stuff not specific to admin manager children
    { AzoDupHandle,    &AdminMgrHandle1,   NULL,        &GenParentHandle1,NO_ERROR },
    { AzoGoSub,        NULL,               NULL,        NULL,             NO_ERROR, OpGenGroup },

    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

// Tests for groups that are children of an application
OPERATION OpAppGroup[] = {
    { AzoEcho, NULL, L"Group objects that are children of an application" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },

    // Do a bunch of stuff not specific to application children
    { AzoDupHandle,    &AppHandle1,        NULL,        &GenParentHandle1,NO_ERROR },
    { AzoGoSub,        NULL,               NULL,        NULL,             NO_ERROR, OpGenGroup },

    { AzoEcho, NULL, L"Test linking to groups that are children of the same admin manager as this group." },
    { AzoGroupOpen,   &AppHandle1,        L"Group A",      &GroupHandleA, NO_ERROR },
    { AzoTestLink,    &AdminMgrHandle1,   (LPWSTR)"Group", &GroupHandleA, AzoGroup, OpTestLink, L"Group A", AZ_PROP_GROUP_APP_MEMBERS },
    { AzoTestLink,    &AdminMgrHandle1,   (LPWSTR)"Group", &GroupHandleA, AzoGroup, OpTestLink, L"Group A", AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoClose,       &GroupHandleA,      NULL,            NULL,          NO_ERROR },

    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

// Tests for groups that are children of a scope
OPERATION OpScopeGroup[] = {
    { AzoEcho, NULL, L"Group objects that are children of a scope" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,        L"Scope 1",  &ScopeHandle1,    NO_ERROR },

    // Do a bunch of stuff not specific to scope children
    { AzoDupHandle,    &ScopeHandle1,      NULL,        &GenParentHandle1,NO_ERROR },
    { AzoGoSub,        NULL,               NULL,        NULL,             NO_ERROR, OpGenGroup },

    { AzoEcho, NULL, L"Test linking to groups that are children of the same admin manager as this group." },
    { AzoGroupOpen,   &ScopeHandle1,      L"Group A",      &GroupHandleA, NO_ERROR },
    { AzoTestLink,    &AdminMgrHandle1,   (LPWSTR)"Group", &GroupHandleA, AzoGroup, OpTestLink, L"Group A", AZ_PROP_GROUP_APP_MEMBERS },
    { AzoTestLink,    &AdminMgrHandle1,   (LPWSTR)"Group", &GroupHandleA, AzoGroup, OpTestLink, L"Group A", AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoClose,       &GroupHandleA,      NULL,            NULL,          NO_ERROR },

    { AzoEcho, NULL, L"Test linking to groups that are children of the same application as this group." },
    { AzoGroupOpen,   &ScopeHandle1,      L"Group A",      &GroupHandleA, NO_ERROR },
    { AzoTestLink,    &AppHandle1,        (LPWSTR)"Group", &GroupHandleA, AzoGroup, OpTestLink, L"Group A", AZ_PROP_GROUP_APP_MEMBERS },
    { AzoTestLink,    &AppHandle1,        (LPWSTR)"Group", &GroupHandleA, AzoGroup, OpTestLink, L"Group A", AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoClose,       &GroupHandleA,      NULL,            NULL,          NO_ERROR },

    { AzoClose,        &ScopeHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

//
// Specific tests for Role objects
//


// Tests for Roles that are children of an application
OPERATION OpAppRole[] = {
    { AzoEcho, NULL, L"Role objects that are children of an application" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },

    { AzoRoleCreate,  &AppHandle1,   L"Role A",   &RoleHandleA,    NO_ERROR },

    // Test linking roles to groups
    { AzoEcho, NULL, L"Test linking to groups that are children of the same admin manager as the role object." },
    { AzoTestLink,    &AdminMgrHandle1,   (LPWSTR)"Group", &RoleHandleA,     AzoGroup, OpTestLink, L"Role A", AZ_PROP_ROLE_APP_MEMBERS },

    { AzoEcho, NULL, L"Test linking to groups that are children of the same application as the role object." },
    { AzoTestLink,    &AppHandle1,   (LPWSTR)"Group", &RoleHandleA,     AzoGroup, OpTestLink, L"Role A", AZ_PROP_ROLE_APP_MEMBERS },

    { AzoEcho, NULL, L"Test linking to SIDs." },
    { AzoTestLink,    &AdminMgrHandle1,   (LPWSTR)"Sid", &RoleHandleA,     AzoGroup, OpTestSid, L"Role A", AZ_PROP_ROLE_MEMBERS },

    // Test linking roles to operations
    { AzoTestLink,    &AppHandle1,   (LPWSTR)"Operation", &RoleHandleA,     AzoOp, OpTestLink, L"Role A", AZ_PROP_ROLE_OPERATIONS },

    { AzoClose,        &RoleHandleA,       NULL,        NULL,             NO_ERROR },

    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

// Tests for Roles that are children of an scope
OPERATION OpScopeRole[] = {
    { AzoEcho, NULL, L"Role objects that are children of a scope" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,        L"Scope 1",  &ScopeHandle1,    NO_ERROR },

    { AzoRoleCreate,  &ScopeHandle1,   L"Role A",   &RoleHandleA,    NO_ERROR },

    // Test linking roles to groups
    { AzoEcho, NULL, L"Test linking to groups that are children of the same scope object as the role object." },
    { AzoTestLink,    &ScopeHandle1,   (LPWSTR)"Group", &RoleHandleA,     AzoGroup, OpTestLink, L"Role A", AZ_PROP_ROLE_APP_MEMBERS },

    { AzoEcho, NULL, L"Test linking to groups that are children of the same application as the role object." },
    { AzoTestLink,    &AppHandle1,   (LPWSTR)"Group", &RoleHandleA,     AzoGroup, OpTestLink, L"Role A", AZ_PROP_ROLE_APP_MEMBERS },

    { AzoEcho, NULL, L"Test linking to SIDs." },
    { AzoTestLink,    &AdminMgrHandle1,   (LPWSTR)"Sid", &RoleHandleA,     AzoGroup, OpTestSid, L"Role A", AZ_PROP_ROLE_MEMBERS },

    { AzoEcho, NULL, L"Test linking to groups that are children of the same admin manager as the role object." },
    { AzoTestLink,    &AdminMgrHandle1,   (LPWSTR)"Group", &RoleHandleA,     AzoGroup, OpTestLink, L"Role A", AZ_PROP_ROLE_APP_MEMBERS },

    // Test linking roles to operations
    { AzoTestLink,    &AppHandle1,   (LPWSTR)"Operation", &RoleHandleA,     AzoOp, OpTestLink, L"Role A", AZ_PROP_ROLE_OPERATIONS },

    { AzoClose,        &RoleHandleA,       NULL,        NULL,             NO_ERROR },

    { AzoClose,        &ScopeHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};


//
// Ensure certain objects can't share names
//
OPERATION OpShare[] = {
    { AzoEcho, NULL, L"Certain objects can't share names" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp2",   &AppHandle2,      NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,        L"Scope 1",  &ScopeHandle1,    NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,        L"Scope 2",  &ScopeHandle2,    NO_ERROR },

    { AzoEcho, NULL, L"Create some tasks and ops as a starting point" },
    { AzoTaskCreate,   &AppHandle1,        L"Task 1",   &TaskHandle1,     NO_ERROR },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoOpCreate,     &AppHandle1,        L"Op 1",     &OpHandle1,       NO_ERROR },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Task and operations can't share names" },
    { AzoTaskCreate,   &AppHandle1,        L"Op 1",     &TaskHandle1,     ERROR_ALREADY_EXISTS },
    { AzoOpCreate,     &AppHandle1,        L"Task 1",   &OpHandle1,       ERROR_ALREADY_EXISTS },

    { AzoEcho, NULL, L"... Even via rename" },
    { AzoOpCreate,     &AppHandle1,        L"Op 2",     &OpHandle1,       NO_ERROR },
    { AzoSetProp,       &OpHandle1,         L"Task 1",   NULL,             ERROR_ALREADY_EXISTS, NULL, NULL, AZ_PROP_NAME },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a task as a starting point" },
    { AzoTaskCreate,   &AppHandle1,        L"Task App", &TaskHandle1,     NO_ERROR },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoTaskCreate,   &ScopeHandle1,      L"Task Scp", &TaskHandle2,     NO_ERROR },
    { AzoClose,        &TaskHandle2,       NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure scope and app task names conflict" },
    { AzoTaskCreate,   &AppHandle1,        L"Task Scp", &TaskHandle1,     ERROR_ALREADY_EXISTS },
    { AzoTaskCreate,   &ScopeHandle1,      L"Task App", &TaskHandle1,     ERROR_ALREADY_EXISTS },

    { AzoEcho, NULL, L"Ensure task names in different scopes don't conflict" },
    { AzoTaskCreate,   &ScopeHandle2,      L"Task Scp", &TaskHandle1,     NO_ERROR },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Scope Tasks and operations can't share names" },
    { AzoTaskCreate,   &ScopeHandle1,      L"Op 1",     &TaskHandle1,     ERROR_ALREADY_EXISTS },
    { AzoOpCreate,     &AppHandle1,        L"Task Scp", &OpHandle1,       ERROR_ALREADY_EXISTS },

    { AzoEcho, NULL, L"Create some groups as a starting point" },
    { AzoGroupCreate,  &AdminMgrHandle1,   L"Group Adm",&GroupHandle1,    NO_ERROR },
    { AzoClose,        &GroupHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,        L"Group App",&GroupHandle1,    NO_ERROR },
    { AzoClose,        &GroupHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle2,        L"Group App2",&GroupHandle2,   NO_ERROR },
    { AzoClose,        &GroupHandle2,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create an app group that conflicts with an adm group, etc" },
    { AzoGroupCreate,  &AppHandle1,        L"Group Adm",&GroupHandleA,    ERROR_ALREADY_EXISTS },
    { AzoGroupCreate,  &AdminMgrHandle1,   L"Group App",&GroupHandleA,    ERROR_ALREADY_EXISTS },

    { AzoEcho, NULL, L"Ensure two apps can have a group by the same name" },
    { AzoGroupCreate,  &AppHandle2,        L"Group App",&GroupHandleA,    NO_ERROR },
    { AzoClose,        &GroupHandleA,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a scope group" },
    { AzoGroupCreate,  &ScopeHandle1,      L"Group Scp",&GroupHandle1,    NO_ERROR },
    { AzoClose,        &GroupHandle1,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a scope group that conflicts with an adm group, etc" },
    { AzoGroupCreate,  &ScopeHandle1,      L"Group Adm",&GroupHandleA,    ERROR_ALREADY_EXISTS },
    { AzoGroupCreate,  &ScopeHandle1,      L"Group App",&GroupHandleA,    ERROR_ALREADY_EXISTS },

    { AzoEcho, NULL, L"Create an app/adm group that conflicts with a scope group" },
    { AzoGroupCreate,  &AppHandle1,        L"Group Scp",&GroupHandleA,    ERROR_ALREADY_EXISTS },
    { AzoGroupCreate,  &AdminMgrHandle1,   L"Group Scp",&GroupHandleA,    ERROR_ALREADY_EXISTS },

    { AzoEcho, NULL, L"Ensure two scopes can have a group by the same name" },
    { AzoGroupCreate,  &ScopeHandle2,      L"Group Scp",&GroupHandle2,    NO_ERROR },
    { AzoClose,        &GroupHandle2,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a role as a starting point" },
    { AzoRoleCreate,   &AppHandle1,        L"Role App", &RoleHandle1,     NO_ERROR },
    { AzoClose,        &RoleHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1,      L"Role Scp", &RoleHandle2,     NO_ERROR },
    { AzoClose,        &RoleHandle2,       NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure scope and app role names conflict" },
    { AzoRoleCreate,   &AppHandle1,        L"Role Scp", &RoleHandle1,     ERROR_ALREADY_EXISTS },
    { AzoRoleCreate,   &ScopeHandle1,      L"Role App", &RoleHandle1,     ERROR_ALREADY_EXISTS },

    { AzoEcho, NULL, L"Ensure role names in different scopes don't conflict" },
    { AzoRoleCreate,   &ScopeHandle2,      L"Role Scp", &RoleHandle1,     NO_ERROR },
    { AzoClose,        &RoleHandle1,       NULL,        NULL,             NO_ERROR },

    { AzoClose,        &ScopeHandle2,      NULL,        NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,      NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle2,        NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};


//
// Ensure peristence works
//
// App object enum
OPERATION OpAppEnum[] = {
    { AzoGetProp,    &GenHandleE,   NULL,        NULL,    NO_ERROR, NULL, NULL, AZ_PROP_NAME },
    { AzoClose,      &GenHandleE,   NULL,        NULL,    NO_ERROR },
    { AzoEndOfList }
};
// Task object enum
OPERATION OpTaskEnum[] = {
    { AzoGetProp,    &GenHandleE,   NULL,        NULL,    NO_ERROR, NULL, NULL, AZ_PROP_NAME },
    { AzoClose,       &GenHandleE,   NULL,        NULL,    NO_ERROR },
    { AzoEndOfList }
};

// Operation object enum
OPERATION OpOpEnum[] = {
    { AzoGetProp,     &GenHandleE,   NULL,        NULL,    NO_ERROR, NULL, NULL, AZ_PROP_NAME },
    { AzoClose,      &GenHandleE,   NULL,        NULL,    NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpPersist[] = {
    { AzoEcho, NULL, L"Ensure objects persist across a close" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoTaskCreate,   &AppHandle1,        L"Task 1",   &TaskHandle1,     NO_ERROR },
    { AzoOpCreate,     &AppHandle1,        L"Op 1",     &OpHandle1,       NO_ERROR },
    { AzoAddProp,      &TaskHandle1,       L"Op 1",     NULL,             NO_ERROR, NULL, NULL, AZ_PROP_TASK_OPERATIONS },
    { AzoGetProp,      &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Op1, AZ_PROP_TASK_OPERATIONS },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoSetProp,      &TaskHandle1,       L"Jscript",  NULL,             NO_ERROR, NULL, L"",         AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoGetProp,      &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"Jscript",  AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,        L"Group 1",  &GroupHandle1,    NO_ERROR },
    { AzoAddProp,      &GroupHandle1,     (LPWSTR)&Sid2,NULL,             NO_ERROR, NULL, NULL, AZ_PROP_GROUP_MEMBERS },
    { AzoGetProp,      &GroupHandle1,      NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Sid2Array, AZ_PROP_GROUP_MEMBERS },
    { AzoClose,        &GroupHandle1,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Abort an object creation and an attribute change" },
    { AzoOpCreate|AzoAbort, &AppHandle1,   L"Op 2",     &OpHandle1,       NO_ERROR },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoOpOpen,       &AppHandle1,        L"Op 2",     &OpHandle1,       ERROR_NOT_FOUND },
    { AzoOpOpen,       &AppHandle1,        L"Op 1",     &OpHandle1,       NO_ERROR },
    { AzoSetProp|AzoAbort, &OpHandle1,    (LPWSTR)&Eight, NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_OPERATION_ID },
    { AzoGetProp,       &OpHandle1,         NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Zero, AZ_PROP_OPERATION_ID },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"See if they're still there" },
    { AzoInit,         NULL,             NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, 0 },
    { AzoAppEnum,      &AdminMgrHandle1,   NULL,        &GenHandleE,      NO_ERROR, OpAppEnum },
    { AzoAppOpen,      &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoTaskEnum,     &AppHandle1,        NULL,        &GenHandleE,      NO_ERROR, OpTaskEnum },
    { AzoTaskOpen,     &AppHandle1,        L"Task 1",   &TaskHandle1,     NO_ERROR },
    { AzoGetProp,      &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Op1, AZ_PROP_TASK_OPERATIONS },
    { AzoGetProp,      &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, L"Jscript",  AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoOpEnum,       &AppHandle1,        NULL,        &GenHandleE,      NO_ERROR, OpOpEnum },
    { AzoOpOpen,       &AppHandle1,        L"Op 1",     &OpHandle1,       NO_ERROR },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoOpOpen,       &AppHandle1,        L"Op 2",     &OpHandle1,       ERROR_NOT_FOUND },
    { AzoGroupOpen,   &AppHandle1,        L"Group 1",  &GroupHandle1,    NO_ERROR },
    { AzoGetProp,      &GroupHandle1,      NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Sid2Array, AZ_PROP_GROUP_MEMBERS },
    { AzoClose,        &GroupHandle1,      NULL,        NULL,             NO_ERROR },


    { AzoEcho, NULL, L"Complain if we try to create a child of non-sumbitted parent" },
    { AzoAppCreate|AzoNoSubmit,    &AdminMgrHandle1,   L"MyApp2",   &AppHandle2,      NO_ERROR },
    { AzoTaskCreate,   &AppHandle2,        L"Task 1",   &TaskHandle2,     ERROR_DS_NO_PARENT_OBJECT },

    { AzoEcho, NULL, L"Complain if we try to link to a non-sumbitted object" },
    { AzoOpCreate|AzoNoSubmit,&AppHandle1, L"Op 3",     &OpHandle1,       NO_ERROR },
    { AzoAddProp,     &TaskHandle1,       L"Op 3",     NULL,             ERROR_NOT_FOUND, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle2,        NULL,        NULL,             NO_ERROR },


    { AzoEcho, NULL, L"Ensure links are re-ordered upon rename" },
    { AzoOpCreate,     &AppHandle1,        L"Op 2",     &OpHandle1,       NO_ERROR },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoAddProp,      &TaskHandle1,       L"Op 2",     NULL,             NO_ERROR, NULL, NULL, AZ_PROP_TASK_OPERATIONS },
    { AzoGetProp,      &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Op12, AZ_PROP_TASK_OPERATIONS },
    { AzoOpOpen,       &AppHandle1,        L"Op 1",     &OpHandle1,       NO_ERROR },
    { AzoSetProp,      &OpHandle1,         L"Op 4",     NULL,             NO_ERROR, NULL, NULL, AZ_PROP_NAME },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoGetProp,      &TaskHandle1,       NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&Op24, AZ_PROP_TASK_OPERATIONS },


    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure the an empty admin manager is persisted" },
    { AzoInit,         NULL,               NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoInit|AzoNoSubmit, NULL,           NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, 0 },

    { AzoEcho, NULL, L"Ensure a restored admin manager is writable" },
    { AzoGetProp,      &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&AzGlTrue,  AZ_PROP_WRITABLE },

    { AzoEcho, NULL, L"Ensure we can create an application in the empty restored admin manager" },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure changes to admin manager are reflected in store" },
    { AzoInit,         NULL,               NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoSetProp,      &AdminMgrHandle1,   L"Desc",     NULL,             NO_ERROR, NULL, NULL,         AZ_PROP_DESCRIPTION },
    { AzoGetProp,      &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR, NULL, L"Desc",  AZ_PROP_DESCRIPTION },
    { AzoInit,         NULL,               NULL,        &AdminMgrHandle2, NO_ERROR, NULL, NULL, 0 },
    { AzoGetProp,      &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR, NULL, L"Desc",  AZ_PROP_DESCRIPTION },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure renames are reflected in updated caches" },
    { AzoInit,         NULL,               NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoInit,         NULL,               NULL,        &AdminMgrHandle2, NO_ERROR, NULL, NULL, 0 },

    { AzoSetProp,      &AppHandle1,        L"NewApp",   NULL,             NO_ERROR, NULL, NULL, AZ_PROP_NAME },
    { AzoGetProp,      &AppHandle1,        NULL,        NULL,             NO_ERROR, NULL, L"NewApp",     AZ_PROP_NAME },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },


    { AzoUpdateCache,  &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure an updated admin manager is writable" },
    { AzoGetProp,      &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&AzGlTrue,  AZ_PROP_WRITABLE },

    { AzoAppOpen,      &AdminMgrHandle2,   L"MyApp",    &AppHandle1,      ERROR_NOT_FOUND },
    { AzoAppOpen,      &AdminMgrHandle2,   L"NewApp",   &AppHandle1,      NO_ERROR },

    { AzoEcho, NULL, L"Ensure a updated app is writable" },
    { AzoGetProp,      &AppHandle1,        NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&AzGlTrue,  AZ_PROP_WRITABLE },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },

    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Ensure that's true even on name conflict" },
    { AzoInit,         NULL,               NULL,        &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"App 1",    &AppHandle1,      NO_ERROR },
    { AzoAppCreate,    &AdminMgrHandle1,   L"App 2",    &AppHandle2,      NO_ERROR },
    { AzoClose,        &AppHandle2,        NULL,        NULL,             NO_ERROR },
    { AzoInit,         NULL,               NULL,        &AdminMgrHandle2, NO_ERROR, NULL, NULL, 0 },

    { AzoAppDelete,    &AdminMgrHandle1,   L"App 2",    &AppHandle1,      NO_ERROR },
    { AzoSetProp,      &AppHandle1,        L"App 2",    NULL,             NO_ERROR, NULL, NULL, AZ_PROP_NAME },
    { AzoGetProp,      &AppHandle1,        NULL,        NULL,             NO_ERROR, NULL, L"App 2",     AZ_PROP_NAME },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },


    { AzoUpdateCache,  &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR },
    { AzoAppEnum,      &AdminMgrHandle2,   NULL,        &GenHandleE,      NO_ERROR, OpAppEnum },
    { AzoAppOpen,      &AdminMgrHandle2,   L"App 2",    &AppHandle1,      NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },

    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle2,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

//
// Perform access check tests
//

#define OP1_NUM 61
ULONG Op1Num = OP1_NUM;
#define OP2_NUM 62
ULONG Op2Num = OP2_NUM;
#define OP3_NUM 63
ULONG Op3Num = OP3_NUM;
#define OP4_NUM 64
ULONG Op4Num = OP4_NUM;

ULONG Ops1[] = { OP1_NUM };
ULONG Ops2[] = { OP2_NUM };
ULONG Ops3[] = { OP3_NUM };
ULONG Ops4[] = { OP4_NUM };
ULONG Ops1234[] = { OP1_NUM, OP2_NUM, OP3_NUM, OP4_NUM };
ULONG OpsInvalid[] = { 8 };

ULONG ResS[] = { NO_ERROR };
ULONG ResF[] = { ERROR_ACCESS_DENIED };
ULONG ResN[] = { 0xFFFFFFFF };
ULONG ResSSSS[] = { NO_ERROR, NO_ERROR, NO_ERROR, NO_ERROR };
ULONG ResFFFF[] = { ERROR_ACCESS_DENIED, ERROR_ACCESS_DENIED, ERROR_ACCESS_DENIED, ERROR_ACCESS_DENIED };
ULONG ResFSSS[] = { ERROR_ACCESS_DENIED, NO_ERROR, NO_ERROR, NO_ERROR };
ULONG ResSSFF[] = { NO_ERROR, NO_ERROR, ERROR_ACCESS_DENIED, ERROR_ACCESS_DENIED };

OPERATION OpAccess[] = {
    { AzoEcho, NULL, L"Create a complete policy data to perform access checks against" },
    { AzoInit,         NULL,               NULL,   &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },

    { AzoEcho, NULL, L"Create some operations" },
    { AzoOpCreate,     &AppHandle1,        L"Op1",      &OpHandle1,       NO_ERROR },
    { AzoSetProp,       &OpHandle1,      (LPWSTR)&Op1Num,NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_OPERATION_ID },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoOpCreate,     &AppHandle1,        L"Op2",      &OpHandle1,       NO_ERROR },
    { AzoSetProp,       &OpHandle1,      (LPWSTR)&Op2Num,NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_OPERATION_ID },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoOpCreate,     &AppHandle1,        L"Op3",      &OpHandle1,       NO_ERROR },
    { AzoSetProp,       &OpHandle1,      (LPWSTR)&Op3Num,NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_OPERATION_ID },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoOpCreate,     &AppHandle1,        L"Op4",      &OpHandle1,       NO_ERROR },
    { AzoSetProp,       &OpHandle1,      (LPWSTR)&Op4Num,NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_OPERATION_ID },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create some tasks" },
    { AzoTaskCreate,   &AppHandle1,        L"TaskOp1",  &TaskHandle1,     NO_ERROR },
    { AzoAddProp,     &TaskHandle1,       L"Op1",      NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoTaskCreate,   &AppHandle1,        L"TaskOp1Op2",&TaskHandle1,    NO_ERROR },
    { AzoAddProp,     &TaskHandle1,       L"Op1",      NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoAddProp,     &TaskHandle1,       L"Op2",      NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoTaskCreate,   &AppHandle1,        L"TaskOp1WithEmptyBizRule",  &TaskHandle1,     NO_ERROR },
    { AzoAddProp,     &TaskHandle1,       L"Op1",      NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoSetProp,     &TaskHandle1,       L"VBScript", NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoSetProp,     &TaskHandle1,       L" ",        NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoTaskCreate,   &AppHandle1,        L"TaskOp1WithTrivialBizRule",  &TaskHandle1,     NO_ERROR },
    { AzoAddProp,     &TaskHandle1,       L"Op1",      NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoSetProp,     &TaskHandle1,       L"VBScript", NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoSetProp,     &TaskHandle1,       L"AccessCheck.BusinessRuleResult = TRUE",        NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create some groups with NT membership" },
    { AzoGroupCreate,  &AppHandle1,         L"GroupWorld",     &GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtBasic,    NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoAddProp,    &GroupHandleA,       (LPWSTR)&SidWorld, NULL,      NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_MEMBERS },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,         L"GroupNotAMember",&GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtBasic,    NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoAddProp,    &GroupHandleA,       (LPWSTR)&Sid1,     NULL,      NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_MEMBERS },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a group using app group membership" },
    { AzoGroupCreate,  &AppHandle1,         L"GroupAppMember",&GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtBasic,    NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoAddProp,    &GroupHandleA,       L"GroupWorld",     NULL,      NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_MEMBERS },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a group using app group non membership - but still member" },
    { AzoGroupCreate,  &AppHandle1,         L"GroupAppNonMember",&GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtBasic,    NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoAddProp,    &GroupHandleA,       L"GroupAppMember",     NULL,      NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_MEMBERS },
    { AzoAddProp,    &GroupHandleA,       L"GroupNotAMember",     NULL,      NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a group using app group non membership - but not member" },
    { AzoGroupCreate,  &AppHandle1,         L"GroupAppReallyNonMember",&GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtBasic,    NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoAddProp,    &GroupHandleA,       L"GroupAppMember",     NULL,      NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_MEMBERS },
    { AzoAddProp,    &GroupHandleA,       L"GroupWorld",     NULL,      NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_NON_MEMBERS },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create some LdapQuery groups" },
    { AzoGroupCreate,  &AppHandle1,         L"GroupLdapYes", &GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtLdap,    NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
#ifdef ENABLE_CLIFFV_ACCOUNT
    { AzoSetProp,    &GroupHandleA,       L"(userAccountControl=1049088)", NULL,      NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
#endif // ENABLE_CLIFFV_ACCOUNT
#ifdef ENABLE_ADMIN_ACCOUNT
    { AzoSetProp,    &GroupHandleA,       L"(userAccountControl=66048)", NULL,      NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
#endif // ENABLE_ADMIN_ACCOUNT
#ifdef ENABLE_CHAITU_ACCOUNT
    { AzoSetProp,    &GroupHandleA,       L"(userAccountControl=512)", NULL,      NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
#endif // ENABLE_CHAITU_ACCOUNT
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,         L"GroupLdapNo", &GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtLdap,    NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoSetProp,    &GroupHandleA,       L"(userAccountControl=1049089)", NULL,      NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },


    { AzoEcho, NULL, L"Create some scopes" },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope", &ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope2",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope3",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope4",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope5",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope6",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope7",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope8",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScope9",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScopeQ1",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScopeQ2",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScopeNoRoles",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,         L"MyScopeP1",&ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Build a context" },
    { AzoInitCFT,      &AppHandle1, (LPWSTR)&TokenHandle, &CCHandle,       NO_ERROR },


    { AzoEcho, NULL, L"Create a role granting op1 access to everyone SID" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope", &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleEveryoneCanOp1", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  (LPWSTR)&SidWorld, NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op1",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check a SID on a role granting access" },
    { AzoAccess,      &CCHandle,      L"MyScope", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Create a role granting op2 access to GroupWorld" },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleGroupWorldCanOp2", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupWorld",     NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op2",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check a app group on a role granting access" },
    { AzoAccess,      &CCHandle,      L"MyScope", (PAZ_HANDLE)&Ops2,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Ask again to check out app group caching" },
    { AzoAccess,      &CCHandle,      L"MyScope", (PAZ_HANDLE)&Ops2,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Create a role not granting op3 access to GroupNotAMember" },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleGroupCantOp3", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupNotAMember",     NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op3",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check a app group on a role not granting access" },
    { AzoAccess,      &CCHandle,      L"MyScope", (PAZ_HANDLE)&Ops3,     NO_ERROR, NULL, (LPWSTR) &ResF, 1 },

    { AzoEcho, NULL, L"Check a scope with no roles" },
    { AzoAccess,      &CCHandle,      L"MyScopeNoRoles", (PAZ_HANDLE)&Ops3,     NO_ERROR, NULL, (LPWSTR) &ResF, 1 },

    { AzoEcho, NULL, L"Check zero operations" },
    { AzoAccess,      &CCHandle,      L"MyScope", (PAZ_HANDLE)&Ops3,     ERROR_INVALID_PARAMETER, NULL, (LPWSTR) &ResF, 0 },

    { AzoEcho, NULL, L"Check an invalid scope name" },
    { AzoAccess,      &CCHandle,      L"MyScopeNameInvalid", (PAZ_HANDLE)&Ops3,     ERROR_SCOPE_NOT_FOUND, NULL, (LPWSTR) &ResF, 1 },

    { AzoEcho, NULL, L"Check an invalid operation number" },
    { AzoAccess,      &CCHandle,      L"MyScope", (PAZ_HANDLE)&OpsInvalid,     ERROR_INVALID_OPERATION, NULL, (LPWSTR) &ResN, 1 },

    { AzoEcho, NULL, L"Create two roles that both grant access" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope2", &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"Role2GroupWorldCanOp2", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupWorld",     NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op2",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"Role2aGroupWorldCanOp2", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupWorld",     NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op2",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check a app group with two roles granting access" },
    { AzoAccess,      &CCHandle,      L"MyScope2", (PAZ_HANDLE)&Ops2,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Create two roles with one granting and one not granting" },
    { AzoRoleCreate,   &ScopeHandle1, L"Role2GroupCantOp3", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupNotAMember",     NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op3",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"Role2GroupWorldCanOp3", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupWorld",     NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op3",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check a app group with one role granting and the other not" },
    { AzoAccess,      &CCHandle,      L"MyScope2", (PAZ_HANDLE)&Ops3,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"... in the other order" },
    { AzoRoleCreate,   &ScopeHandle1, L"Role2GroupWorldCanOp4", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupWorld",     NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op4",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"Role2GroupCantOp4", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupNotAMember",     NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op4",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"...In the other order" },
    { AzoAccess,      &CCHandle,      L"MyScope2", (PAZ_HANDLE)&Ops4,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Try multiple operations" },
    { AzoAccess,      &CCHandle,      L"MyScope2", (PAZ_HANDLE)&Ops1234,     NO_ERROR, NULL, (LPWSTR) &ResFSSS, 4 },

    { AzoEcho, NULL, L"Create a role granting op1 access to AppGroup" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope3",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleAppGroupCanOp1", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupAppMember", NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op1",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoAccess,      &CCHandle,      L"MyScope3", (PAZ_HANDLE)&Ops1,      NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Create a role granting op1 access to AppGroup with non member group" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope4",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"Role2AppGroupCanOp1", &RoleHandleA,NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupAppNonMember", NULL,          NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op1",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoAccess,      &CCHandle,      L"MyScope4", (PAZ_HANDLE)&Ops1,      NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Create a role granting op1 access to AppGroup with non member group - really not member" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope5",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"Role3AppGroupCanOp1", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupAppReallyNonMember", NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op1",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoAccess,      &CCHandle,      L"MyScope5", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResF, 1 },

    { AzoEcho, NULL, L"Create a role granting op1 access to everyone SID via a task" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope6",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleEveryoneCanOp1ViaTask1", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  (LPWSTR)&SidWorld, NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"TaskOp1",        NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_TASKS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check granted access via a task" },
    { AzoAccess,      &CCHandle,      L"MyScope6", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Create a role granting op1 and op2 access to everyone SID via a task" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope7",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleEveryoneCanOp1Op2ViaTask1", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  (LPWSTR)&SidWorld, NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"TaskOp1Op2",        NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_TASKS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check granted access to two ops via a task" },
    { AzoAccess,      &CCHandle,      L"MyScope7", (PAZ_HANDLE)&Ops1234,  NO_ERROR, NULL, (LPWSTR) &ResSSFF, 4 },

    { AzoEcho, NULL, L"Create a role granting op1 access to an LDAP query group" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScopeQ1",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleLdapCanOp1", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupLdapYes",    NULL,            NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op1",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

#ifdef ENABLE_DC_DOWN
    { AzoEcho, NULL, L"Check LDAP query groups with the DC down" },
    { AzoAccess,      &CCHandle,      L"MyScopeQ1", (PAZ_HANDLE)&Ops1,    ERROR_NO_SUCH_DOMAIN, NULL, (LPWSTR) &ResF, 1 },
    { AzoAccess,      &CCHandle,      L"MyScopeQ1", (PAZ_HANDLE)&Ops1,    ERROR_NO_SUCH_DOMAIN, NULL, (LPWSTR) &ResF, 1 },
    { AzoSleep, NULL, L"\n\nPlug the DC in now!!!", NULL, NO_ERROR, NULL, NULL, 30 },
#endif // ENABLE_DC_DOWN

    { AzoEcho, NULL, L"Check granted access via LDAP query group" },
#ifdef ENABLE_NON_DS_ACCOUNT
    { AzoAccess,      &CCHandle,      L"MyScopeQ1", (PAZ_HANDLE)&Ops1,    NO_ERROR, NULL, (LPWSTR) &ResF, 1 },
#else // ENABLE_NON_DS_ACCOUNT
    { AzoAccess,      &CCHandle,      L"MyScopeQ1", (PAZ_HANDLE)&Ops1,    NO_ERROR, NULL, (LPWSTR) &ResS, 1 },
#endif // ENABLE_NON_DS_ACCOUNT

    { AzoEcho, NULL, L"Try again to check the cache" },
#ifdef ENABLE_NON_DS_ACCOUNT
    { AzoAccess,      &CCHandle,      L"MyScopeQ1", (PAZ_HANDLE)&Ops1,    NO_ERROR, NULL, (LPWSTR) &ResF, 1 },
#else // ENABLE_NON_DS_ACCOUNT
    { AzoAccess,      &CCHandle,      L"MyScopeQ1", (PAZ_HANDLE)&Ops1,    NO_ERROR, NULL, (LPWSTR) &ResS, 1 },
#endif // ENABLE_NON_DS_ACCOUNT

    { AzoEcho, NULL, L"Create a role granting op1 access to an LDAP query group" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScopeQ2",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1,   L"RoleLdapCannotOp1", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupLdapNo",    NULL,            NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op1",            NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check failed access via LDAP query group" },
    { AzoAccess,      &CCHandle,      L"MyScopeQ2", (PAZ_HANDLE)&Ops1,    NO_ERROR, NULL, (LPWSTR) &ResF, 1 },

    // These tests have to be after the ENABLE_DC_DOWN tests
    { AzoEcho, NULL, L"Test if all the query property opcodes work" },
#ifdef ENABLE_CLIFFV_ACCOUNT
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"CN=Cliff Van Dyke,OU=Users,OU=ITG,DC=ntdev,DC=microsoft,DC=com",  AZ_PROP_CLIENT_CONTEXT_USER_DN },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"NTDEV\\cliffv",  AZ_PROP_CLIENT_CONTEXT_USER_SAM_COMPAT },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"Cliff Van Dyke",  AZ_PROP_CLIENT_CONTEXT_USER_DISPLAY },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"{ebff0213-bec7-4c11-bd47-06c80df7f356}",  AZ_PROP_CLIENT_CONTEXT_USER_GUID },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"ntdev.microsoft.com/ITG/Users/Cliff Van Dyke",  AZ_PROP_CLIENT_CONTEXT_USER_CANONICAL },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"[email protected]",  AZ_PROP_CLIENT_CONTEXT_USER_UPN },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"NTDEV.MICROSOFT.COM\\cliffv",  AZ_PROP_CLIENT_CONTEXT_USER_DNS_SAM_COMPAT },
#endif // ENABLE_CLIFFV_ACCOUNT
#ifdef ENABLE_CHAITU_ACCOUNT
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"CN=Chaitanya Upadhyay,OU=Users,OU=ITG,DC=ntdev,DC=microsoft,DC=com",  AZ_PROP_CLIENT_CONTEXT_USER_DN },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"NTDEV\\chaitu",  AZ_PROP_CLIENT_CONTEXT_USER_SAM_COMPAT },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"Chaitanya Upadhyay",  AZ_PROP_CLIENT_CONTEXT_USER_DISPLAY },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"{54bd4c43-861e-4b68-9e6c-0b8eec0b4847}",  AZ_PROP_CLIENT_CONTEXT_USER_GUID },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"ntdev.microsoft.com/ITG/Users/Chaitanya Upadhyay",  AZ_PROP_CLIENT_CONTEXT_USER_CANONICAL },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"[email protected]",  AZ_PROP_CLIENT_CONTEXT_USER_UPN },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"NTDEV.MICROSOFT.COM\\chaitu",  AZ_PROP_CLIENT_CONTEXT_USER_DNS_SAM_COMPAT },
#endif // ENABLE_CHAITU_ACCOUNT
#ifdef ENABLE_NT4_ACCOUNT
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NO_SUCH_DOMAIN, NULL, L"CN=,OU=Users,OU=ITG,DC=ntdev,DC=microsoft,DC=com",  AZ_PROP_CLIENT_CONTEXT_USER_DN },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"SECDOMNT4\\Administrator",  AZ_PROP_CLIENT_CONTEXT_USER_SAM_COMPAT },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NO_SUCH_DOMAIN, NULL, L"Cliff Van Dyke",  AZ_PROP_CLIENT_CONTEXT_USER_DISPLAY },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NO_SUCH_DOMAIN, NULL, L"{ebff0213-bec7-4c11-bd47-06c80df7f356}",  AZ_PROP_CLIENT_CONTEXT_USER_GUID },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NO_SUCH_DOMAIN, NULL, L"ntdev.microsoft.com/ITG/Users/Cliff Van Dyke",  AZ_PROP_CLIENT_CONTEXT_USER_CANONICAL },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NO_SUCH_DOMAIN, NULL, L"[email protected]",  AZ_PROP_CLIENT_CONTEXT_USER_UPN },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NONE_MAPPED, NULL, L"NTDEV.MICROSOFT.COM\\cliffv",  AZ_PROP_CLIENT_CONTEXT_USER_DNS_SAM_COMPAT },
#endif // ENABLE_NT4_ACCOUNT
#ifdef ENABLE_LOCAL_ACCOUNT
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NONE_MAPPED, NULL, L"CN=Cliff Van Dyke,OU=Users,OU=ITG,DC=ntdev,DC=microsoft,DC=com",  AZ_PROP_CLIENT_CONTEXT_USER_DN },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             NO_ERROR, NULL, L"CLIFFV5-PRO\\Administrator",  AZ_PROP_CLIENT_CONTEXT_USER_SAM_COMPAT },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NONE_MAPPED, NULL, L"Cliff Van Dyke",  AZ_PROP_CLIENT_CONTEXT_USER_DISPLAY },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NONE_MAPPED, NULL, L"{ebff0213-bec7-4c11-bd47-06c80df7f356}",  AZ_PROP_CLIENT_CONTEXT_USER_GUID },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NONE_MAPPED, NULL, L"ntdev.microsoft.com/ITG/Users/Cliff Van Dyke",  AZ_PROP_CLIENT_CONTEXT_USER_CANONICAL },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NONE_MAPPED, NULL, L"[email protected]",  AZ_PROP_CLIENT_CONTEXT_USER_UPN },
    { AzoGetProp,      &CCHandle,       NULL,        NULL,             ERROR_NONE_MAPPED, NULL, L"NTDEV.MICROSOFT.COM\\cliffv",  AZ_PROP_CLIENT_CONTEXT_USER_DNS_SAM_COMPAT },
#endif // ENABLE_LOCAL_ACCOUNT

    { AzoEcho, NULL, L"... except the generic ones" },
    { AzoGetProp,      &CCHandle,   NULL,        NULL,    ERROR_INVALID_PARAMETER, NULL, NULL, AZ_PROP_NAME },
    { AzoGetProp,      &CCHandle,   NULL,        NULL,    ERROR_INVALID_PARAMETER, NULL, NULL, AZ_PROP_DESCRIPTION },


    { AzoEcho, NULL, L"Create a role denying op1 access to everyone SID via a task with a bizrule" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope8",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleEveryoneCannotOp1ViaTask1WithBizrule", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  (LPWSTR)&SidWorld, NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"TaskOp1WithEmptyBizRule",        NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_TASKS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },


#if 0
    { AzoEcho, NULL, L"Check denied access via a task with bizrule" },
    { AzoAccess,      &CCHandle,      L"MyScope8", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResF, 1 },
#endif // 0

    { AzoEcho, NULL, L"Create a role granting op1 access to everyone SID via a task with a bizrule" },
    { AzoScopeOpen,    &AppHandle1,   L"MyScope9",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleEveryoneCanOp1ViaTask1WithBizrule", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  (LPWSTR)&SidWorld, NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"TaskOp1WithTrivialBizRule",        NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_TASKS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check granted access via a task with bizrule" },
    { AzoAccess,      &CCHandle,      L"MyScope9", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },
    { AzoAccess,      &CCHandle,      L"MyScope9", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Create a role granting op1 access to everyone SID via a task with a bizrule (using parameters)" },
    { AzoTaskCreate,   &AppHandle1,   L"TaskOp1WithParameterBizrule",  &TaskHandle1,     NO_ERROR },
    { AzoAddProp,     &TaskHandle1,  L"Op1",      NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoSetProp,     &TaskHandle1,  L"VBScript", NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoSetProp,     &TaskHandle1,  L"Dim Amount\nAmount = AccessCheck.GetParameter( \"Amount\" )\nif Amount < 500 then AccessCheckBusinessRuleResult = TRUE",        NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE },
    { AzoClose,        &TaskHandle1,  NULL,        NULL,             NO_ERROR },
    { AzoScopeOpen,    &AppHandle1,   L"MyScopeP1",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleEveryoneCanOp1WithParameterBizrule", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  (LPWSTR)&SidWorld, NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"TaskOp1WithParameterBizrule",        NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_TASKS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    // This fails because I don't pass any parameters to AccessCheck and the Bizrule wants the AmountParameter
    { AzoEcho, NULL, L"Check granted access via a task with bizrule (using parameters)" },
    { AzoAccess,      &CCHandle,      L"MyScopeP1", (PAZ_HANDLE)&Ops1,     ERROR_INVALID_PARAMETER, NULL, (LPWSTR) &ResF, 1 },

    { AzoEcho, NULL, L"Create a role using a task with an infinite loop" },
    { AzoTaskCreate,   &AppHandle1,   L"TaskInfiniteLoop", &TaskHandle1,     NO_ERROR },
    { AzoAddProp,     &TaskHandle1,  L"Op1",      NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoSetProp,     &TaskHandle1,  L"VBScript", NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoSetProp,     &TaskHandle1,  L"While True\nWend",        NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE },
    { AzoClose,        &TaskHandle1,  NULL,        NULL,             NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,   L"MyScopeI1",       &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1, L"RoleInfinite", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  (LPWSTR)&SidWorld, NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"TaskInfiniteLoop",        NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_TASKS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Set the timeout to 5 seconds" },
    { AzoGetProp,    &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&FortyFiveThousand, AZ_PROP_ADMIN_SCRIPT_ENGINE_TIMEOUT },
    { AzoSetProp,    &AdminMgrHandle1,     (LPWSTR)&FiveThousand,NULL,    NO_ERROR, NULL, NULL,         AZ_PROP_ADMIN_SCRIPT_ENGINE_TIMEOUT },
    { AzoGetProp,    &AdminMgrHandle1,     NULL,        NULL,             NO_ERROR, NULL, (LPWSTR)&FiveThousand,  AZ_PROP_ADMIN_SCRIPT_ENGINE_TIMEOUT },

    { AzoEcho, NULL, L"Check granted access via a task with infinite loop" },
    { AzoAccess,      &CCHandle,      L"MyScopeI1", (PAZ_HANDLE)&Ops1,     ERROR_TIMEOUT, NULL, (LPWSTR) &ResF, 1 },

    { AzoEcho, NULL, L"Create a role under application granting op1 access to everyone SID" },
    { AzoRoleCreate,   &AppHandle1, L"AppRoleEveryoneCanOp1", &RoleHandleA, NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  (LPWSTR)&SidWorld, NULL,              NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op1",            NULL,              NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,       NULL,         NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Check a SID on a role granting access with default scope" },
    { AzoAccess,      &CCHandle,      NULL, (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoEcho, NULL, L"Check access granted with default scope anda role granting op1 access to everyone SID" },
    { AzoRoleCreate, &AppHandle1,  L"NoScopeRoleEveryoneCanOp1", &RoleHandleA,      NO_ERROR },
    { AzoAddProp,    &RoleHandleA, (LPWSTR)&SidWorld,            NULL,              NO_ERROR, NULL, NULL, AZ_PROP_ROLE_MEMBERS },
    { AzoAddProp,    &RoleHandleA, L"Op1",                       NULL,              NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,      &RoleHandleA, NULL,                         NULL,              NO_ERROR },

    { AzoEcho,       NULL,         L"Check a SID on a role granting access" },
    { AzoAccess,     &CCHandle,    NULL, (PAZ_HANDLE)&Ops1, NO_ERROR, NULL, (LPWSTR) &ResS, 1 },

    { AzoClose,        &CCHandle,          NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

//
// Special case access checks
//  These are tests we don't always want to run, but we have an option to run them
//  under some circumstances
//

OPERATION OpAccessBegin[] = {
    { AzoEcho, NULL, L"Create a smaller database to do special case access checks" },
    { AzoInit,         NULL,               NULL,   &AdminMgrHandle1, NO_ERROR, NULL, NULL, AZ_ADMIN_FLAG_CREATE },
    { AzoAppCreate,    &AdminMgrHandle1,   L"MyApp",    &AppHandle1,      NO_ERROR },
    { AzoOpCreate,     &AppHandle1,        L"Op1",      &OpHandle1,       NO_ERROR },
    { AzoSetProp,       &OpHandle1,      (LPWSTR)&Op1Num,NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_OPERATION_ID },
    { AzoClose,        &OpHandle1,         NULL,        NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,         L"Group1",  &GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,  (LPWSTR)&GtBasic,NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoAddProp,    &GroupHandleA,       (LPWSTR)&SidWorld, NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_MEMBERS },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,         L"Group2",  &GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtBasic, NULL,       NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoAddProp,    &GroupHandleA,       L"Group1",  NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_APP_MEMBERS },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,         L"Group3",  &GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,  (LPWSTR)&GtBasic,NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,         L"Group4",  &GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,  (LPWSTR)&GtBasic,NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },
    { AzoGroupCreate,  &AppHandle1,         L"GroupLdapYes", &GroupHandleA,    NO_ERROR },
    { AzoSetProp,    &GroupHandleA,       (LPWSTR)&GtLdap,    NULL,      NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },
#ifdef ENABLE_CLIFFV_ACCOUNT
    { AzoSetProp,    &GroupHandleA,       L"(userAccountControl=1049088)", NULL,      NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
#endif // ENABLE_CLIFFV_ACCOUNT
#ifdef ENABLE_CHAITU_ACCOUNT
    { AzoSetProp,    &GroupHandleA,       L"(userAccountControl=512)", NULL,      NO_ERROR, NULL, NULL,        AZ_PROP_GROUP_LDAP_QUERY },
#endif // ENABLE_CHAITU_ACCOUNT
    { AzoClose,        &GroupHandleA,       NULL,       NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a trivial bizrule" },
    { AzoTaskCreate,   &AppHandle1,        L"TaskOp1WithTrivialBizRule",  &TaskHandle1,     NO_ERROR },
    { AzoAddProp,     &TaskHandle1,       L"Op1",      NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_OPERATIONS },
    { AzoSetProp,     &TaskHandle1,       L"VBScript", NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE_LANGUAGE },
    { AzoSetProp,     &TaskHandle1,       L"AccessCheck.BusinessRuleResult = TRUE",        NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE },
    { AzoClose,        &TaskHandle1,       NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Create a role granting op1 access to everyone SID via a task with a bizrule" },
    { AzoScopeCreate,  &AppHandle1,        L"MyScope",  &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1,      L"RoleEveryoneCanOp1ViaTask1WithBizrule", &RoleHandleA, NO_ERROR },
    { AzoAddProp,      &RoleHandleA,       L"Group2",    NULL,             NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,      &RoleHandleA,       L"TaskOp1WithTrivialBizRule", NULL, NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_TASKS },
    { AzoClose,        &RoleHandleA,       NULL,        NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L".. Another role but using LDAP this time" },
    { AzoScopeCreate,  &AppHandle1,        L"MyScopeLdap",  &ScopeHandle1,    NO_ERROR },
    { AzoRoleCreate,   &ScopeHandle1,      L"RoleEveryoneCanOp1ViaTask1WithBizrule", &RoleHandleA, NO_ERROR },
    { AzoAddProp,      &RoleHandleA,       L"GroupLdapYes", NULL,         NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,      &RoleHandleA,       L"TaskOp1WithTrivialBizRule", NULL, NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_TASKS },
    { AzoClose,        &RoleHandleA,       NULL,        NULL,             NO_ERROR },
    { AzoClose,        &ScopeHandle1,      NULL,        NULL,             NO_ERROR },

    { AzoEcho, NULL, L"Build a context" },
    { AzoInitCFT,      &AppHandle1, (LPWSTR)&TokenHandle, &CCHandle,       NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpAccess2[] = {
    { AzoAccess,      &CCHandle,      L"MyScope", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },
    { AzoEndOfList }
};

// Flush group membership cache, too
OPERATION OpAccess2Ldap[] = {
    { AzoEcho, NULL, L"main" },
    { AzoGroupOpen,    &AppHandle1,         L"Group2",   &GroupHandle1,    NO_ERROR },
    { AzoAddProp|AzoNoSubmit,    &GroupHandle1,       L"Group4",   NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_MEMBERS },
    { AzoClose,        &GroupHandle1,       NULL,        NULL,             NO_ERROR },
    { AzoAccess,      &CCHandle,      L"MyScopeLdap", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },
    { AzoEndOfList }
};

//
// Test a group with lots of sids as members
//
OPERATION OpSidxBegin[] = {
    { AzoEcho, NULL, L"Create a group with many sid members" },
    { AzoGroupCreate,  &AppHandle1,   L"GroupManySid",  &GroupHandleA,      NO_ERROR },
    { AzoSetProp,    &GroupHandleA, (LPWSTR)&GtBasic, NULL,               NO_ERROR, NULL, NULL,      AZ_PROP_GROUP_TYPE },

    { AzoEndOfList }
};

OPERATION OpSidx[] = {
    { AzoAddProp|   AzoNoSubmit, &GroupHandleA, (LPWSTR)&SidX,    NULL,               NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_MEMBERS },
    { AzoEndOfList }
};

OPERATION OpSidxEnd[] = {
    { AzoEcho, NULL, L"Do an access check on the group" },
    { AzoRoleCreate,   &AppHandle1,   L"RoleManySid",   &RoleHandleA,       NO_ERROR },
    { AzoAddProp,     &RoleHandleA,  L"GroupManySid",  NULL,               NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_APP_MEMBERS },
    { AzoAddProp,     &RoleHandleA,  L"Op1",           NULL,               NO_ERROR, NULL, NULL,   AZ_PROP_ROLE_OPERATIONS },
    { AzoClose,        &RoleHandleA,  NULL,             NULL,               NO_ERROR },
    { AzoScopeCreate,  &AppHandle1,   L"ScopeManySid",  &ScopeHandle1,      NO_ERROR },
    { AzoClose,        &ScopeHandle1, NULL,             NULL,               NO_ERROR },

    { AzoAccess,       &CCHandle,     L"ScopeManySid",  (PAZ_HANDLE)&Ops1,  NO_ERROR, NULL, (LPWSTR) &ResF, 1 },
    { AzoClose,        &GroupHandleA, NULL,             NULL,               NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpAccessEnd[] = {
    { AzoClose,        &CCHandle,          NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AppHandle1,        NULL,        NULL,             NO_ERROR },
    { AzoAdmDelete,    &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoClose,        &AdminMgrHandle1,   NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};


OPERATION OpAccess1m[] = {
    { AzoEcho, NULL, L"Second thread" },
    { AzoInitCFT,      &AppHandle1, (LPWSTR)&TokenHandle, &CCHandle2,       NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpAccess2m[] = {
    { AzoEcho, NULL, L"Second thread access" },
    { AzoAccess,      &CCHandle2,      L"MyScope", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },
    { AzoEndOfList }
};

// Flush group membership cache, too
OPERATION OpAccess2mLdap[] = {
    { AzoEcho, NULL, L"Second thread access" },
    { AzoGroupOpen,    &AppHandle1,         L"Group2",   &GroupHandleT,    NO_ERROR },
    { AzoAddProp|AzoNoSubmit,    &GroupHandleT,       L"Group3",   NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_MEMBERS },
    { AzoClose,        &GroupHandleT,       NULL,        NULL,             NO_ERROR },
    { AzoAccess,      &CCHandle2,      L"MyScopeLdap", (PAZ_HANDLE)&Ops1,     NO_ERROR, NULL, (LPWSTR) &ResS, 1 },
    { AzoEndOfList }
};

OPERATION OpAccess3m[] = {
    { AzoEcho, NULL, L"Second thread close" },
    { AzoClose,        &CCHandle2,          NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};


OPERATION OpBizruleThread[] = {
    { AzoEcho, NULL, L"BizRule change thread" },
    { AzoTaskOpen,     &AppHandle1,        L"TaskOp1WithTrivialBizRule",  &TaskHandleT,     NO_ERROR },
    { AzoSetProp,     &TaskHandleT,       L"AccessCheck.BusinessRuleResult = TRUE",        NULL,             NO_ERROR, NULL, NULL,      AZ_PROP_TASK_BIZRULE },
    { AzoClose,        &TaskHandleT,       NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};

OPERATION OpGroupThread[] = {
    { AzoEcho, NULL, L"Group change thread" },
    { AzoGroupOpen,    &AppHandle1,         L"Group2",   &GroupHandleT,    NO_ERROR },
    { AzoAddProp,    &GroupHandleT,       L"Group3",   NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_MEMBERS },
    { AzoRemProp,    &GroupHandleT,       L"Group3",   NULL,             NO_ERROR, NULL, NULL,           AZ_PROP_GROUP_APP_MEMBERS },
    { AzoClose,        &GroupHandleT,       NULL,        NULL,             NO_ERROR },
    { AzoEndOfList }
};


WCHAR ScopeBillions[64];

OPERATION OpBillions[] = {
    { AzoScopeCreate,  &AppHandle1,         ScopeBillions, &ScopeHandle1,    NO_ERROR },
    { AzoClose,        &ScopeHandle1,       NULL,       NULL,             NO_ERROR },
    { AzoEndOfList }
};




VOID
DumpBuffer(
    PVOID Buffer,
    DWORD BufferSize
    )
/*++

Routine Description:

    Dumps the buffer content on to the debugger output.

Arguments:

    Buffer: buffer pointer.

    BufferSize: size of the buffer.

Return Value:

    none

--*/
{
#define NUM_CHARS 16

    DWORD i, limit;
    CHAR TextBuffer[NUM_CHARS + 1];
    LPBYTE BufferPtr = Buffer;


    printf("------------------------------------\n");

    //
    // Hex dump of the bytes
    //
    limit = ((BufferSize - 1) / NUM_CHARS + 1) * NUM_CHARS;

    for (i = 0; i < limit; i++) {

        if (i < BufferSize) {

            printf("%02x ", BufferPtr[i]);

            if (BufferPtr[i] < 31 ) {
                TextBuffer[i % NUM_CHARS] = '.';
            } else if (BufferPtr[i] == '\0') {
                TextBuffer[i % NUM_CHARS] = ' ';
            } else {
                TextBuffer[i % NUM_CHARS] = (CHAR) BufferPtr[i];
            }

        } else {

            printf("  ");
            TextBuffer[i % NUM_CHARS] = ' ';

        }

        if ((i + 1) % NUM_CHARS == 0) {
            TextBuffer[NUM_CHARS] = 0;
            printf("  %s\n", TextBuffer);
        }

    }

    printf("------------------------------------\n");
}

LPSTR
FindSymbolicNameForStatus(
    DWORD Id
    )
{
    ULONG i;

    i = 0;
    if (Id == 0) {
        return "STATUS_SUCCESS";
    }

    if (Id & 0xC0000000) {
        while (ntstatusSymbolicNames[ i ].SymbolicName) {
            if (ntstatusSymbolicNames[ i ].MessageId == (NTSTATUS)Id) {
                return ntstatusSymbolicNames[ i ].SymbolicName;
            } else {
                i += 1;
            }
        }
    }

    while (winerrorSymbolicNames[ i ].SymbolicName) {
        if (winerrorSymbolicNames[ i ].MessageId == Id) {
            return winerrorSymbolicNames[ i ].SymbolicName;
        } else {
            i += 1;
        }
    }

#ifdef notdef
    while (neteventSymbolicNames[ i ].SymbolicName) {
        if (neteventSymbolicNames[ i ].MessageId == Id) {
            return neteventSymbolicNames[ i ].SymbolicName
        } else {
            i += 1;
        }
    }
#endif // notdef

    return NULL;
}

VOID
PrintStatus(
    NET_API_STATUS NetStatus
    )
/*++

Routine Description:

    Print a net status code.

Arguments:

    NetStatus - The net status code to print.

Return Value:

    None

--*/
{

    switch (NetStatus) {
    case NO_ERROR:
        printf( "NO_ERROR" );
        break;

    case NERR_DCNotFound:
        printf( "NERR_DCNotFound" );
        break;

    case ERROR_LOGON_FAILURE:
        printf( "ERROR_LOGON_FAILURE" );
        break;

    case ERROR_ACCESS_DENIED:
        printf( "ERROR_ACCESS_DENIED" );
        break;

    case ERROR_NOT_SUPPORTED:
        printf( "ERROR_NOT_SUPPORTED" );
        break;

    case ERROR_NO_LOGON_SERVERS:
        printf( "ERROR_NO_LOGON_SERVERS" );
        break;

    case ERROR_NO_SUCH_DOMAIN:
        printf( "ERROR_NO_SUCH_DOMAIN" );
        break;

    case ERROR_NO_TRUST_LSA_SECRET:
        printf( "ERROR_NO_TRUST_LSA_SECRET" );
        break;

    case ERROR_NO_TRUST_SAM_ACCOUNT:
        printf( "ERROR_NO_TRUST_SAM_ACCOUNT" );
        break;

    case ERROR_DOMAIN_TRUST_INCONSISTENT:
        printf( "ERROR_DOMAIN_TRUST_INCONSISTENT" );
        break;

    case ERROR_BAD_NETPATH:
        printf( "ERROR_BAD_NETPATH" );
        break;

    case ERROR_FILE_NOT_FOUND:
        printf( "ERROR_FILE_NOT_FOUND" );
        break;

    case NERR_NetNotStarted:
        printf( "NERR_NetNotStarted" );
        break;

    case NERR_WkstaNotStarted:
        printf( "NERR_WkstaNotStarted" );
        break;

    case NERR_ServerNotStarted:
        printf( "NERR_ServerNotStarted" );
        break;

    case NERR_BrowserNotStarted:
        printf( "NERR_BrowserNotStarted" );
        break;

    case NERR_ServiceNotInstalled:
        printf( "NERR_ServiceNotInstalled" );
        break;

    case NERR_BadTransactConfig:
        printf( "NERR_BadTransactConfig" );
        break;

    case SEC_E_NO_SPM:
        printf( "SEC_E_NO_SPM" );
        break;
    case SEC_E_BAD_PKGID:
        printf( "SEC_E_BAD_PKGID" ); break;
    case SEC_E_NOT_OWNER:
        printf( "SEC_E_NOT_OWNER" ); break;
    case SEC_E_CANNOT_INSTALL:
        printf( "SEC_E_CANNOT_INSTALL" ); break;
    case SEC_E_INVALID_TOKEN:
        printf( "SEC_E_INVALID_TOKEN" ); break;
    case SEC_E_CANNOT_PACK:
        printf( "SEC_E_CANNOT_PACK" ); break;
    case SEC_E_QOP_NOT_SUPPORTED:
        printf( "SEC_E_QOP_NOT_SUPPORTED" ); break;
    case SEC_E_NO_IMPERSONATION:
        printf( "SEC_E_NO_IMPERSONATION" ); break;
    case SEC_E_LOGON_DENIED:
        printf( "SEC_E_LOGON_DENIED" ); break;
    case SEC_E_UNKNOWN_CREDENTIALS:
        printf( "SEC_E_UNKNOWN_CREDENTIALS" ); break;
    case SEC_E_NO_CREDENTIALS:
        printf( "SEC_E_NO_CREDENTIALS" ); break;
    case SEC_E_MESSAGE_ALTERED:
        printf( "SEC_E_MESSAGE_ALTERED" ); break;
    case SEC_E_OUT_OF_SEQUENCE:
        printf( "SEC_E_OUT_OF_SEQUENCE" ); break;
    case SEC_E_INSUFFICIENT_MEMORY:
        printf( "SEC_E_INSUFFICIENT_MEMORY" ); break;
    case SEC_E_INVALID_HANDLE:
        printf( "SEC_E_INVALID_HANDLE" ); break;
    case SEC_E_NOT_SUPPORTED:
        printf( "SEC_E_NOT_SUPPORTED" ); break;
#define OLESCRIPT_E_SYNTAX _HRESULT_TYPEDEF_(0x80020101L)
    case OLESCRIPT_E_SYNTAX:
        printf( "OLESCRIPT_E_SYNTAX" ); break;


    default: {
        LPSTR Name = FindSymbolicNameForStatus( NetStatus );

        if ( Name == NULL ) {
            if ( NetStatus & 0x80000000 ) {
                HRESULT hr = NetStatus;
                if ((HRESULT_FACILITY(hr) == FACILITY_WIN32) && (FAILED(hr))) {
                    DWORD TempStatus;

                    TempStatus = HRESULT_CODE(hr);

                    if ( TempStatus == ERROR_SUCCESS ) {
                        TempStatus = ERROR_INTERNAL_ERROR;
                    }
                    printf( "(0x%lx is ", hr );
                    PrintStatus( TempStatus );
                    printf( ")" );

                } else {
                    printf( "(0x%lx)", NetStatus );
                }
            } else {
                printf( "(%lu)", NetStatus );
            }
        } else {
            printf( "%s", Name );
        }
        break;
    }
    }

}

VOID
PrintIndent(
    IN ULONG Indentation,
    IN BOOLEAN Error
    )
/*++

Routine Description:

    Print line prefix for log file

Arguments:

    Indentation - Number of spaces to indent text by.

    Error - True if this is a program failure.

Return Value:

    None.

--*/
{
    static LPSTR Blanks = "                                                           ";

    printf( "%*.*s", Indentation, Indentation, Blanks );

    if ( Error ) {
        printf("[ERR] ");
    }

}

//return type IDs
typedef enum _ENUM_AZ_DATATYPE
{
    ENUM_AZ_NONE = 0,
    ENUM_AZ_BSTR,
    ENUM_AZ_LONG,
    ENUM_AZ_BSTR_ARRAY,
    ENUM_AZ_SID_ARRAY,
    ENUM_AZ_BOOL,
} ENUM_AZ_DATATYPE, *PENUM_AZ_DATATYPE;


HRESULT
myAzGetPropertyDataType(
    IN   LONG  lPropId,
    OUT  ENUM_AZ_DATATYPE *pDataType)
/*+++
Description:
    a routine to map property ID to a data type
Arguments:
    lPropId - property ID
    pDataType - pointer to hold data type
Return:
---*/
{
    HRESULT  hr;
    ENUM_AZ_DATATYPE  dataType;

    // check property ID and assign data type
    switch (lPropId)
    {
        case AZ_PROP_NAME:
        case AZ_PROP_DESCRIPTION:
        case AZ_PROP_APPLICATION_DATA:
        case AZ_PROP_APPLICATION_AUTHZ_INTERFACE_CLSID:
        case AZ_PROP_APPLICATION_VERSION:
        case AZ_PROP_TASK_BIZRULE:
        case AZ_PROP_TASK_BIZRULE_LANGUAGE:
        case AZ_PROP_TASK_BIZRULE_IMPORTED_PATH:
        case AZ_PROP_GROUP_LDAP_QUERY:
        case AZ_PROP_CLIENT_CONTEXT_USER_DN:
        case AZ_PROP_CLIENT_CONTEXT_USER_SAM_COMPAT:
        case AZ_PROP_CLIENT_CONTEXT_USER_DISPLAY:
        case AZ_PROP_CLIENT_CONTEXT_USER_GUID:
        case AZ_PROP_CLIENT_CONTEXT_USER_CANONICAL:
        case AZ_PROP_CLIENT_CONTEXT_USER_UPN:
        case AZ_PROP_CLIENT_CONTEXT_USER_DNS_SAM_COMPAT:
        case AZ_PROP_ADMIN_TARGET_MACHINE:
        case AZ_PROP_CLIENT_CONTEXT_ROLE_FOR_ACCESS_CHECK:
            dataType = ENUM_AZ_BSTR;
        break;

        case AZ_PROP_ADMIN_DOMAIN_TIMEOUT:
        case AZ_PROP_ADMIN_SCRIPT_ENGINE_TIMEOUT:
        case AZ_PROP_ADMIN_MAX_SCRIPT_ENGINES:
        case AZ_PROP_OPERATION_ID:
        case AZ_PROP_GROUP_TYPE:
        case AZ_PROP_APPLY_STORE_SACL:
        case AZ_PROP_GENERATE_AUDITS:
        //case AZ_PROP_ADMIN_MAJOR_VERSION: make it invisible to clients
        //case AZ_PROP_ADMIN_MINOR_VERSION: make it invisible to clients
            dataType = ENUM_AZ_LONG;
        break;

        case AZ_PROP_TASK_OPERATIONS:
        case AZ_PROP_TASK_TASKS:
        case AZ_PROP_GROUP_APP_MEMBERS:
        case AZ_PROP_GROUP_APP_NON_MEMBERS:
        case AZ_PROP_ROLE_APP_MEMBERS:
        case AZ_PROP_ROLE_OPERATIONS:
        case AZ_PROP_ROLE_TASKS:
            dataType = ENUM_AZ_BSTR_ARRAY;
        break;

        case AZ_PROP_GROUP_MEMBERS:
        case AZ_PROP_GROUP_NON_MEMBERS:
        case AZ_PROP_ROLE_MEMBERS:
        case AZ_PROP_POLICY_ADMINS:
        case AZ_PROP_POLICY_READERS:
        case AZ_PROP_DELEGATED_POLICY_USERS:
            dataType = ENUM_AZ_SID_ARRAY;
        break;

        case AZ_PROP_TASK_IS_ROLE_DEFINITION:
        case AZ_PROP_WRITABLE:
            dataType = ENUM_AZ_BOOL;
        break;

        default:
            hr = E_INVALIDARG;
            goto error;
        break;
    }

    *pDataType = dataType;

    hr = S_OK;
error:
    return hr;
}

BOOL
DoOperations(
    IN POPERATION OperationsToDo,
    IN ULONG Indentation,
    IN ULONG SpecificOpcodeOffset,
    IN LPSTR EchoPrefix
    )
/*++

Routine Description:

    Do a set of operations

Arguments:

    OperationsToDo - a list of operations to do

    Indentation - Number of spaces to indent text by.
        This value increases on recursive calls.

    SpecificOpcodeOffset - Specifies an amount to add to a generic opcode to map
        it to a specific opcode.

    EchoPrefix - Specifies a string to print before all AzoEcho strings

Return Value:

    TRUE - tests completed successfully
    FALSE - tests failed

--*/
{
    BOOL RetVal = TRUE;
    POPERATION Operation;
    LPSTR OpName;
    ULONG Opcode;

    PVOID PropertyValue = NULL;
    ENUM_AZ_DATATYPE PropType;

    ULONG PropertyId;

    BOOLEAN WasGetProperty;
    HANDLE SubmitHandle;
    ULONG SubmitFlags;
    BOOLEAN SubmitOk;

    BOOLEAN UpdateCache;
    BOOLEAN InitUponDelete;

    ULONG SleepTime;

    ULONG EnumerationContext = 0;
    BOOLEAN FirstIteration = TRUE;

    DWORD WinStatus;
    DWORD RealWinStatus;
    DWORD TempWinStatus;
    HRESULT hr;

    CHAR BigBuffer[1000];
    PAZ_STRING_ARRAY StringArray1;
    PAZ_STRING_ARRAY StringArray2;

    PAZ_SID_ARRAY SidArray1;
    PAZ_SID_ARRAY SidArray2;

    LPWSTR ScopeNames[8];
    ULONG Results[50];
    static AZ_HANDLE GlobalAdminManagerHandle = NULL;
    static AZ_HANDLE SavedGlobalAdminManagerHandle = NULL;

    ULONG i;

    //
    // Leave room between tests
    //

    if ( Indentation == 0 ) {
        if ( !Silent ) {
            printf( "\n\n" );
        }
    }


    //
    // Loop through each of the operations
    //

    for ( Operation=OperationsToDo; Operation->Opcode != AzoEndOfList && RetVal; ) {

        //
        // Mark that this change doesn't need to be submitted (by default)
        //

        SubmitHandle = INVALID_HANDLE_VALUE;

        //
        // Compute the flags to pass to submit if a submit turns out to be needed
        //

        Opcode = Operation->Opcode;
        SubmitFlags = 0;

        if ( Opcode & AzoAbort ) {
            SubmitFlags |= AZ_SUBMIT_FLAG_ABORT;
            Opcode &= ~AzoAbort;
        }

        SubmitOk = TRUE;

        if ( Opcode & AzoNoSubmit ) {
            SubmitOk = FALSE;
            Opcode &= ~AzoNoSubmit;
        }

        UpdateCache = TRUE;

        if ( Opcode & AzoNoUpdateCache ) {
            UpdateCache = FALSE;
            Opcode &= ~AzoNoUpdateCache;
        }

        InitUponDelete = FALSE;



        //
        // Compute the mapped property ID
        //

        if ( TestLinkPropId != 0 && Operation->PropertyId != 0 ) {
            PropertyId = TestLinkPropId;
        } else {
            PropertyId = Operation->PropertyId;
        }


        //
        // Setup for get/set property
        //

        PropertyValue = NULL;

        //
        // Convert property id to type
        //

        hr = myAzGetPropertyDataType( PropertyId, &PropType );

        if ( FAILED(hr) ) {
            PropType = ENUM_AZ_NONE;
        }

        WasGetProperty = FALSE;

        SleepTime = 0;

        //
        // Map generic opcodes to a specific opcode
        //

        if ( Opcode < AzoGenMax ) {
            ASSERT( SpecificOpcodeOffset != 0 );
            Opcode += SpecificOpcodeOffset;

        } else if ( Opcode >= AzoTl && Opcode < AzoTlMax ) {
            ASSERT( TestLinkOpcodeOffset != 0 );
            Opcode = Opcode - AzoTl + TestLinkOpcodeOffset;
        }


        //
        // Perform the requested operation
        //
        //
        // Admin Manager APIs
        //

        switch ( Opcode ) {
        case AzoInit:
            OpName = "AzInitialize";
            WinStatus = AzInitialize(
                            AzGlTestFile,
                            PropertyId, // Flags
                            0,  // reserved
                            Operation->OutputHandle );

            SubmitHandle = *Operation->OutputHandle;
            UpdateCache = FALSE;


            //
            // Initialize another copy for refresh testing
            //

            if ( !NoUpdateCache && WinStatus == NO_ERROR && GlobalAdminManagerHandle == NULL ) {
                SavedGlobalAdminManagerHandle = *Operation->OutputHandle;
                TempWinStatus = AzInitialize(
                                    AzGlTestFile,
                                    PropertyId, // Flags
                                    0,  // reserved
                                    &GlobalAdminManagerHandle );
                if ( TempWinStatus != NO_ERROR ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "Cannot AzInitialize new database. %ld\n", TempWinStatus );
                }
            }



            break;

        case AzoUpdateCache:
            OpName = "AzUpdateCache";
            WinStatus = AzUpdateCache(
                            *Operation->InputHandle );

            break;

        case AzoGetProp:
            OpName = "AzGetProperty";

            WinStatus = AzGetProperty(
                            *Operation->InputHandle,
                            PropertyId,
                            0,  // reserved
                            &PropertyValue );

            WasGetProperty = TRUE;
            break;

        case AzoSetProp:
            OpName = "AzSetProperty";

            WinStatus = AzSetProperty(
                            *Operation->InputHandle,
                            PropertyId,
                            0,  // reserved
                            Operation->Parameter1 );

            SubmitHandle = *Operation->InputHandle;
            break;

        case AzoAddProp:
            OpName = "AzAddProperty";

            WinStatus = AzAddPropertyItem(
                            *Operation->InputHandle,
                            PropertyId,
                            0,  // reserved
                            Operation->Parameter1 );

            SubmitHandle = *Operation->InputHandle;

            break;

        case AzoRemProp:
            OpName = "AzRemProperty";

            WinStatus = AzRemovePropertyItem(
                            *Operation->InputHandle,
                            PropertyId,
                            0,  // reserved
                            Operation->Parameter1 );

            SubmitHandle = *Operation->InputHandle;

            break;

        case AzoAdmDelete:
            InitUponDelete = TRUE;
            /* Drop through */
        case AzoAdmDeleteNoInit:

            //
            // Take this oportunity to ensure we can initialize from this store
            //
            WinStatus = NO_ERROR;
            if  ( InitUponDelete && !NoInitAllTests ) {
                AZ_HANDLE AdminManagerHandle;

                WinStatus = AzInitialize(
                                AzGlTestFile,
                                0,  // No flags
                                0,  // reserved
                                &AdminManagerHandle );

                if ( WinStatus != NO_ERROR ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "Cannot AzInitialize existing database.\n" );
                } else {
                    AzCloseHandle( AdminManagerHandle, 0 );
                }

            }

            OpName = "AzAdminManagerDelete";
            if ( RetVal ) {
                WinStatus = AzAdminManagerDelete(
                                *Operation->InputHandle,
                                0 );  // reserved
            }

            UpdateCache = FALSE;

            break;




        //
        // Application APIs
        //
        case AzoAppCreate:
            OpName = "AzApplicationCreate";
            WinStatus = AzApplicationCreate(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            SubmitHandle = *Operation->OutputHandle;

            break;

        case AzoAppOpen:
            OpName = "AzApplicationOpen";
            WinStatus = AzApplicationOpen(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            break;

        case AzoAppEnum:
            OpName = "AzApplicationEnum";
            WinStatus = AzApplicationEnum(
                            *Operation->InputHandle,
                            0,  // reserved
                            &EnumerationContext,
                            Operation->OutputHandle );

            break;

        case AzoAppDelete:
            OpName = "AzApplicationDelete";
            WinStatus = AzApplicationDelete(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0 );  // reserved

            SubmitHandle = *Operation->InputHandle;

            break;


        //
        // Operation APIs
        //
        case AzoOpCreate:
            OpName = "AzOperationCreate";
            WinStatus = AzOperationCreate(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            SubmitHandle = *Operation->OutputHandle;

            break;

        case AzoOpOpen:
            OpName = "AzOperationOpen";
            WinStatus = AzOperationOpen(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            break;

        case AzoOpEnum:
            OpName = "AzOperationEnum";
            WinStatus = AzOperationEnum(
                            *Operation->InputHandle,
                            0,  // reserved
                            &EnumerationContext,
                            Operation->OutputHandle );

            break;

        case AzoOpDelete:
            OpName = "AzOperationDelete";
            WinStatus = AzOperationDelete(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0 );  // reserved

            SubmitHandle = *Operation->InputHandle;

            break;


        //
        // Task APIs
        //
        case AzoTaskCreate:
            OpName = "AzTaskCreate";
            WinStatus = AzTaskCreate(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            SubmitHandle = *Operation->OutputHandle;

            break;

        case AzoTaskOpen:
            OpName = "AzTaskOpen";
            WinStatus = AzTaskOpen(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            break;

        case AzoTaskEnum:
            OpName = "AzTaskEnum";
            WinStatus = AzTaskEnum(
                            *Operation->InputHandle,
                            0,  // reserved
                            &EnumerationContext,
                            Operation->OutputHandle );

            break;

        case AzoTaskDelete:
            OpName = "AzTaskDelete";
            WinStatus = AzTaskDelete(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0 );  // reserved

            SubmitHandle = *Operation->InputHandle;

            break;


        //
        // Scope APIs
        //
        case AzoScopeCreate:
            OpName = "AzScopeCreate";
            WinStatus = AzScopeCreate(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            SubmitHandle = *Operation->OutputHandle;

            break;

        case AzoScopeOpen:
            OpName = "AzScopeOpen";
            WinStatus = AzScopeOpen(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            break;

        case AzoScopeEnum:
            OpName = "AzScopeEnum";
            WinStatus = AzScopeEnum(
                            *Operation->InputHandle,
                            0,  // reserved
                            &EnumerationContext,
                            Operation->OutputHandle );

            break;

        case AzoScopeDelete:
            OpName = "AzScopeDelete";
            WinStatus = AzScopeDelete(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0 );  // reserved

            SubmitHandle = *Operation->InputHandle;

            break;


        //
        // Group APIs
        //
        case AzoGroupCreate:
            OpName = "AzGroupCreate";
            WinStatus = AzGroupCreate(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            SubmitHandle = *Operation->OutputHandle;

            break;

        case AzoGroupOpen:
            OpName = "AzGroupOpen";
            WinStatus = AzGroupOpen(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            break;

        case AzoGroupEnum:
            OpName = "AzGroupEnum";
            WinStatus = AzGroupEnum(
                            *Operation->InputHandle,
                            0,  // reserved
                            &EnumerationContext,
                            Operation->OutputHandle );

            break;

        case AzoGroupDelete:
            OpName = "AzGroupDelete";
            WinStatus = AzGroupDelete(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0 );  // reserved

            SubmitHandle = *Operation->InputHandle;

            break;


        //
        // Role APIs
        //
        case AzoRoleCreate:
            OpName = "AzRoleCreate";
            WinStatus = AzRoleCreate(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            SubmitHandle = *Operation->OutputHandle;

            break;

        case AzoRoleOpen:
            OpName = "AzRoleOpen";
            WinStatus = AzRoleOpen(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0,  // reserved
                            Operation->OutputHandle );

            break;

        case AzoRoleEnum:
            OpName = "AzRoleEnum";
            WinStatus = AzRoleEnum(
                            *Operation->InputHandle,
                            0,  // reserved
                            &EnumerationContext,
                            Operation->OutputHandle );

            break;

        case AzoRoleDelete:
            OpName = "AzRoleDelete";
            WinStatus = AzRoleDelete(
                            *Operation->InputHandle,
                            Operation->Parameter1,
                            0 );  // reserved

            SubmitHandle = *Operation->InputHandle;

            break;


        //
        // ClientContext APIs
        //

        case AzoInitCFT:
            OpName = "AzInitializeContextFromToken";

            WinStatus = AzInitializeContextFromToken(
                                *Operation->InputHandle,
                                (HANDLE)*Operation->Parameter1,
                                0,  // reserved
                                Operation->OutputHandle );

            break;

        case AzoAccess:
            OpName = "AzContextAccessCheck";

            ScopeNames[0] = Operation->Parameter1;
            WinStatus = AzContextAccessCheck(
                                *Operation->InputHandle,
                                L"FredObject",
                                (*ScopeNames == NULL)?0:1,  // ScopeCount
                                (*ScopeNames == NULL)? NULL : ScopeNames,
                                Operation->PropertyId,  // OperationCount
                                (PULONG)Operation->OutputHandle,// Operations
                                Results,
                                NULL,
                                NULL,
                                NULL,
                                NULL,
                                NULL,
                                NULL );

            break;


        case AzoClose:

            //
            // If this is the close of the admin manager object,
            //  close my corresponding handle, too
            //
            if ( SavedGlobalAdminManagerHandle != NULL &&
                 *Operation->InputHandle == SavedGlobalAdminManagerHandle ) {

                TempWinStatus = AzCloseHandle( GlobalAdminManagerHandle, 0 );

                if (TempWinStatus != NO_ERROR ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "Cannot AzCloseHandle on refresh database. %ld\n", TempWinStatus );
                }

                GlobalAdminManagerHandle = NULL;
                SavedGlobalAdminManagerHandle = NULL;
            }

            OpName = "AzCloseHandle";
            WinStatus = AzCloseHandle(
                            *Operation->InputHandle,
                            0 );  // reserved

            break;

        // Pseudo function test links between objects
        case AzoTestLink:
            OpName = "TestLink";

            // Handle to the parent of the object being linked from
            TestLinkHandleP = *Operation->InputHandle;

            // Handle to the object being linked from
            TestLinkHandleA = *Operation->OutputHandle;

            // PropId to use for all set/get property
            TestLinkPropId = PropertyId;

            // Opcode offset to use for linked-to objects
            TestLinkOpcodeOffset = Operation->ExpectedStatus;

            // Name of the object being linked from
            wcscpy(TestLinkObjectName, Operation->ExpectedParameter1);


            WinStatus = Operation->ExpectedStatus;

            //
            // Build a new echo prefix
            //

            strcpy( BigBuffer, EchoPrefix );
            strcat( BigBuffer, "->" );
            strcat( BigBuffer, (LPSTR)Operation->Parameter1 );

            //
            // Print a description of the operation
            //

            if ( !Silent ) {
                PrintIndent( Indentation, FALSE );
                printf( "\n%s - Test linking '%s' objects to the object named '%ws' using propid '%ld'.\n",
                    BigBuffer,
                    Operation->Parameter1,
                    TestLinkObjectName,
                    TestLinkPropId );
            }

            UpdateCache = FALSE;

            break;

        // Pseudo function to duplicate a handle
        case AzoDupHandle:
            OpName = "DupHandle";
            *Operation->OutputHandle = *Operation->InputHandle;
            WinStatus = NO_ERROR;
            UpdateCache = FALSE;

            break;

        // Pseudo function to execute a "subroutine" of operations
        case AzoGoSub:
            OpName = "GoSub";
            WinStatus = NO_ERROR;
            UpdateCache = FALSE;

            break;

        // Pseudo function to echo text to stdout
        case AzoSleep:
            SleepTime = Operation->PropertyId;
            /* Drop through */

        case AzoEcho:
            OpName = BigBuffer;
            strcpy( OpName, "\n");
            if ( EchoPrefix ) {
                strcat( OpName, EchoPrefix );
                strcat( OpName, " -" );
            }
            WinStatus = NO_ERROR;
            UpdateCache = FALSE;

            break;

        default:

            OpName = "<Unknown>";
            PrintIndent( Indentation+4, TRUE );
            RetVal = FALSE;
            printf( "Need to fix test app to handle a new opcode: %ld\n", Opcode );
            WinStatus = Operation->ExpectedStatus;
            break;

        }

        //
        // Print the operation
        //

        if ( FirstIteration ) {

            if ( Opcode != AzoTestLink ) {

                if ( !Silent ) {
                    PrintIndent( Indentation, FALSE );
                    printf( "%s ", OpName );
                }

                if ( Operation->Parameter1 != NULL ) {
                    LPWSTR TempString;
                    switch ( PropType ) {
                    case ENUM_AZ_NONE:
                    case ENUM_AZ_BSTR:
                    case ENUM_AZ_BSTR_ARRAY:
                        if ( !Silent ) {
                            printf( "'%ws' ", Operation->Parameter1 );
                        }
                        break;
                    case ENUM_AZ_LONG:
                    case ENUM_AZ_BOOL:
                        if ( !Silent ) {
                            printf( "'%ld' ", *(PULONG)Operation->Parameter1 );
                        }
                        break;
                    case ENUM_AZ_SID_ARRAY:
                        if ( !ConvertSidToStringSidW( (PSID)Operation->Parameter1,
                                                      &TempString ) ) {
                            PrintIndent( Indentation+4, TRUE );
                            RetVal = FALSE;
                            printf( "Cannot convert sid.\n" );

                        } else {
                            if ( !Silent ) {
                                printf( "'%ws'", TempString );
                            }
                        }
                        break;
                    default:
                        if ( !Silent ) {
                            printf( "%ld '%ws' ", PropType, Operation->Parameter1 );
                        }
                        ASSERT(FALSE);
                    }
                }
                if ( PropertyId != 0 ) {
                    if ( !Silent ) {
                        printf( "(%ld) ", PropertyId );
                    }
                }

                if ( Operation->ExpectedStatus != NO_ERROR ) {

                    if ( !Silent ) {
                        printf("(");
                        PrintStatus( Operation->ExpectedStatus );
                        printf(") ");
                    }
                }
                if ( !Silent ) {
                    printf( "\n" );
                }

                if ( SleepTime != 0 ) {
                    ULONG t;
                    PrintIndent( Indentation, FALSE );
                    printf( "Sleeping %ld seconds", SleepTime );
                    for ( t=0;t<SleepTime;t++) {
                        printf(".");
                        Sleep(1000);
                    }
                    printf("\n");

                }
            }
        }
        FirstIteration = FALSE;

        //
        // Handle ERROR_NO_MORE_ITEMS/NO_ERROR mapping
        //

        RealWinStatus = WinStatus;
        if ( Operation->EnumOperations != NULL ) {
            if ( WinStatus == ERROR_NO_MORE_ITEMS ) {
                WinStatus = NO_ERROR;
            }
        }


        //
        // Ensure we got the right status code
        //

        if ( WinStatus != Operation->ExpectedStatus ) {
            PrintIndent( Indentation+4, TRUE );
            RetVal = FALSE;
            printf( "Returned '" );
            PrintStatus( WinStatus );
            printf( "' instead of '");
            PrintStatus( Operation->ExpectedStatus );
            printf( "'");
            printf( "\n" );
            break;
        }

        //
        // Do GetProperty specific code
        //

        if ( WinStatus == NO_ERROR && WasGetProperty ) {

            //
            // Print the property
            //

            switch ( PropType ) {
            case ENUM_AZ_BSTR:
                if ( PropertyValue == NULL ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "<NULL>\n", PropertyValue );
                } else {
                    if ( !Silent ) {
                        PrintIndent( Indentation+4, FALSE );
                        printf( "'%ws'\n", PropertyValue );
                    }
                }

                //
                // Check if that value is expected
                //

                if ( Operation->ExpectedParameter1 != NULL &&
                     (PropertyValue == NULL ||
                     _wcsicmp( Operation->ExpectedParameter1, PropertyValue) != 0 )) {

                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "Expected '%ws' instead of '%ws'\n", Operation->ExpectedParameter1, PropertyValue );
                }

                break;

            case ENUM_AZ_BSTR_ARRAY:
                StringArray1 = (PAZ_STRING_ARRAY) PropertyValue;;

                if ( PropertyValue == NULL ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "<NULL>\n", PropertyValue );
                } else {

                    for ( i=0; i<StringArray1->StringCount; i++ ) {
                        if ( !Silent ) {
                            PrintIndent( Indentation+4, FALSE );
                            printf( "'%ws'\n", StringArray1->Strings[i] );
                        }
                    }
                }

                //
                // Check if that value is expected
                //

                if ( Operation->ExpectedParameter1 != NULL ) {
                    StringArray2 = (PAZ_STRING_ARRAY)Operation->ExpectedParameter1;

                    if ( StringArray1->StringCount != StringArray2->StringCount ) {
                        PrintIndent( Indentation+4, TRUE );
                        RetVal = FALSE;
                        printf( "Expected '%ld' strings instead of '%ld' strings\n", StringArray2->StringCount, StringArray1->StringCount );
                    } else {

                        for ( i=0; i<StringArray1->StringCount; i++ ) {

                            if ( wcscmp( StringArray1->Strings[i], StringArray2->Strings[i]) != 0 ) {

                                PrintIndent( Indentation+4, TRUE );
                                RetVal = FALSE;
                                printf( "Expected string %ld to be '%ws' instead of '%ws'\n",
                                        i,
                                        StringArray2->Strings[i],
                                        StringArray1->Strings[i] );

                            }
                        }
                    }
                }

                break;

            case ENUM_AZ_LONG:
            case ENUM_AZ_BOOL:
                if ( PropertyValue == NULL ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "<NULL>\n", PropertyValue );
                } else {
                    if ( !Silent ) {
                        PrintIndent( Indentation+4, FALSE );
                        printf( "'%ld'\n", *(PULONG)PropertyValue );
                    }
                }

                //
                // Check if that value is expected
                //

                if ( *(PULONG)(Operation->ExpectedParameter1) != *(PULONG)PropertyValue ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "Expected '%ld' instead of '%ld'\n",
                                 *(PULONG)(Operation->ExpectedParameter1),
                                 *(PULONG)PropertyValue );
                }
                break;

            case ENUM_AZ_SID_ARRAY:
                SidArray1 = (PAZ_SID_ARRAY) PropertyValue;;

                if ( PropertyValue == NULL ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;
                    printf( "<NULL>\n" );
                } else {
                    LPWSTR TempString;

                    for ( i=0; i<SidArray1->SidCount; i++ ) {
                        if ( !Silent ) {
                            PrintIndent( Indentation+4, FALSE );
                        }

                        if ( !ConvertSidToStringSidW( SidArray1->Sids[i],
                                                      &TempString ) ) {
                            PrintIndent( Indentation+4, TRUE );
                            RetVal = FALSE;
                            printf( "Cannot convert sid.\n" );

                        } else {
                            if ( !Silent ) {
                               printf( "'%ws'\n", TempString );
                            }
                        }
                    }
                }

                //
                // Check if that value is expected
                //

                if ( Operation->ExpectedParameter1 != NULL ) {
                    SidArray2 = (PAZ_SID_ARRAY)Operation->ExpectedParameter1;

                    if ( SidArray1->SidCount != SidArray2->SidCount ) {
                        PrintIndent( Indentation+4, TRUE );
                        RetVal = FALSE;
                        printf( "Expected '%ld' sids instead of '%ld' sids\n", SidArray2->SidCount, SidArray1->SidCount );
                    } else {

                        for ( i=0; i<SidArray1->SidCount; i++ ) {

                            if ( !EqualSid( SidArray1->Sids[i], SidArray2->Sids[i]) ) {
                                LPWSTR TempString1;
                                LPWSTR TempString2;

                                if ( !ConvertSidToStringSidW( SidArray1->Sids[i],
                                                             &TempString1 ) ) {
                                    PrintIndent( Indentation+4, TRUE );
                                    RetVal = FALSE;
                                    printf( "Cannot convert sid.\n" );
                                    continue;
                                }

                                if ( !ConvertSidToStringSidW( SidArray2->Sids[i],
                                                             &TempString2 ) ) {
                                    PrintIndent( Indentation+4, TRUE );
                                    RetVal = FALSE;
                                    printf( "Cannot convert sid.\n" );
                                    continue;
                                }

                                PrintIndent( Indentation+4, TRUE );
                                RetVal = FALSE;
                                printf( "Expected string %ld to be '%ws' instead of '%ws'\n",
                                        i,
                                        TempString2,
                                        TempString1 );

                            }
                        }
                    }
                }

                break;

            default:
                ASSERT(FALSE);
            }

            //
            // Free the returned buffer
            //

            AzFreeMemory( PropertyValue );

        }

        //
        // Submit the changes to the database
        //

        if ( WinStatus == NO_ERROR &&
             SubmitHandle != INVALID_HANDLE_VALUE &&
             SubmitOk ) {

            WinStatus = AzSubmit( SubmitHandle,
                                  SubmitFlags,
                                  0);  // reserved

            if ( WinStatus != NO_ERROR ) {
                PrintIndent( Indentation+4, TRUE );
                RetVal = FALSE;
                printf( "AzSubmit failed: " );
                PrintStatus( WinStatus );
                printf( "\n" );
            }

        }

        //
        // Update the cache on our parallel admin manager handle
        //

        if ( UpdateCache && GlobalAdminManagerHandle != NULL ) {

            TempWinStatus = AzUpdateCache( GlobalAdminManagerHandle );

            if ( TempWinStatus != NO_ERROR ) {
                PrintIndent( Indentation+4, TRUE );
                RetVal = FALSE;
                printf( "AzUpdateCache failed: " );
                PrintStatus( TempWinStatus );
                printf( "\n" );
            }

        }


        //
        // Execute a "subroutine" of operations
        //

        if ( Opcode == AzoGoSub ) {

            if (!DoOperations( Operation->EnumOperations, Indentation + 4, SpecificOpcodeOffset, EchoPrefix ) ) {
                RetVal = FALSE;
            }

        //
        // Execute a the special TestLink "subroutine" of operations
        //

        } else if ( Opcode == AzoTestLink ) {

            if (!DoOperations( Operation->EnumOperations, Indentation + 4, SpecificOpcodeOffset, BigBuffer ) ) {
                RetVal = FALSE;
            }

            TestLinkPropId = 0;

        //
        // Check the results of an access check
        //

        } else if ( Opcode == AzoAccess && WinStatus == NO_ERROR ) {

            for ( i=0; i<Operation->PropertyId; i++ ) {

                if ( ((PULONG)(Operation->ExpectedParameter1))[i] != Results[i] ) {
                    PrintIndent( Indentation+4, TRUE );
                    RetVal = FALSE;

                    printf("Operation %ld: Expected '",
                           ((PULONG)(Operation->OutputHandle))[i] );

                    PrintStatus( ((PULONG)(Operation->ExpectedParameter1))[i] );

                    printf("' instead of '" );

                    PrintStatus( Results[i] );
                    printf("'\n");

                }
            }


        //
        // Do enumeration specific code
        //

        } else if ( Operation->EnumOperations != NULL && RealWinStatus == NO_ERROR ) {

            if ( !Silent ) {
                PrintIndent( Indentation+4, FALSE );
                printf( "%ld:\n", EnumerationContext );
            }

            if (!DoOperations( Operation->EnumOperations, Indentation + 8, SpecificOpcodeOffset, EchoPrefix ) ) {
                RetVal = FALSE;
                break;
            }

            continue;
        }

        //
        // Do the next operation
        //

        EnumerationContext = 0;
        FirstIteration = TRUE;
        Operation++;
    }

    return RetVal;
}

DWORD
AzComInitialize(
    OUT PBOOL ComState
    )
/*++

Routine Description:

    This routine initializes COM.  If the caller uses the "C" api, the caller must initialize COM
    in each thread before calling any other AZ api.

    The calling must free all AZ handles before uninitializing COM.

Arguments:

    State - State to pass to AzComUninitialize

Return Value:

    NO_ERROR - The operation was successful.
        The caller should call AzComUninitialize on this thread.

--*/
{
    DWORD WinStatus = NO_ERROR;
    HRESULT hr;

    //
    // Initialize COM
    //

    *ComState = FALSE;

    hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);

    if (hr == S_OK || hr == S_FALSE) {
        *ComState = TRUE;

    } else if (hr != RPC_E_CHANGED_MODE) {
        WinStatus = hr;
    }

    return WinStatus;
}

VOID
AzComUninitialize(
    IN BOOL ComState
    )
/*++

Routine Description:

    This routine un-initializes COM.  It should be called once for each thread that successfully
    calls AzComInitialize.

Arguments:

    State - State returned from AzComInitialize

Return Value:

    NO_ERROR - The operation was successful.

--*/
{
    if ( ComState) {
        CoUninitialize();
    }
}


DWORD
AccessCheckThread(
    LPVOID lpThreadParameter
    )
/*++

Routine Description:

    This routine implements a second thread to do access checks in.

    The purpose of the thread is to test bizrules which behave differently if more than one thread is
    executing the bizrule.

Arguments:

    Not used.

Return Value:

    NO_ERROR - The operation was successful.

--*/
{
    DWORD WinStatus;
    DWORD ComState;
    BOOLEAN UseLdap = (BOOLEAN) lpThreadParameter;


    Sleep( 60 );
    WinStatus = AzComInitialize( &ComState );

    if ( WinStatus != NO_ERROR ) {
        printf( "Cannot cominitialize %ld\n", WinStatus );
        goto Cleanup;
    }

    //
    // Do AccessCheck specific tests
    //
    if ( !DoOperations( OpAccess1m, 0, 0, "Access1m" ) ) {
        goto Cleanup;
    }

    {
        DWORD Ticks;
        ULONG i;
        Ticks = GetTickCount();
        for ( i=0; i<900; i++ ) {
            if ( UseLdap ) {
                if ( !DoOperations( OpAccess2mLdap, 0, 0, "Access2mLdap" ) ) {
                    goto Cleanup;
                }
            } else {
                if ( !DoOperations( OpAccess2m, 0, 0, "Access2m" ) ) {
                    goto Cleanup;
                }
            }

            // Sleep a bit to allow other thread a change to use our cached script
            Sleep(10);
        }
        Ticks = GetTickCount() - Ticks;
        printf( "%ld milliseconds\n", Ticks );
    }
    if ( !DoOperations( OpAccess3m, 0, 0, "Access3m" ) ) {
        goto Cleanup;
    }

Cleanup:
    AzComUninitialize( ComState );
    return NO_ERROR;
}

DWORD
BizRuleChangeThread(
    LPVOID lpThreadParameter
    )
/*++

Routine Description:

    This routine implements a second thread to change the bizrule while access check is using it.

Arguments:

    Not used.

Return Value:

    NO_ERROR - The operation was successful.

--*/
{
    DWORD WinStatus;
    DWORD ComState;

    ULONG i;
    WinStatus = AzComInitialize( &ComState );

    if ( WinStatus != NO_ERROR ) {
        printf( "Cannot cominitialize %ld\n", WinStatus );
        goto Cleanup;
    }

    //
    // Do this several times to allow it to interfere with the main thread in several places
    //
    for ( i=0; i<100; i++ ) {



        Sleep( 60 );

        //
        // Do Change bizrule specific tests
        //
        if ( !DoOperations( OpBizruleThread, 0, 0, "BizRuleThread" ) ) {
            goto Cleanup;
        }

    }

Cleanup:
    AzComUninitialize( ComState );
    return NO_ERROR;
}

DWORD
GroupChangeThread(
    LPVOID lpThreadParameter
    )
/*++

Routine Description:

    This routine implements a second thread to change a group membership while access check is using it.

Arguments:

    Not used.

Return Value:

    NO_ERROR - The operation was successful.

--*/
{
    DWORD WinStatus;
    DWORD ComState;

    ULONG i;
    WinStatus = AzComInitialize( &ComState );

    if ( WinStatus != NO_ERROR ) {
        printf( "Cannot cominitialize %ld\n", WinStatus );
        goto Cleanup;
    }

    //
    // Do this several times to allow it to interfere with the main thread in several places
    //
    for ( i=0; i<100; i++ ) {



        Sleep( 60 );

        //
        // Do Change bizrule specific tests
        //
        if ( !DoOperations( OpGroupThread, 0, 0, "GroupThread" ) ) {
            goto Cleanup;
        }

    }

Cleanup:
    AzComUninitialize( ComState );
    return NO_ERROR;
}

int __cdecl
main(
    IN int argc,
    IN char ** argv
    )
/*++

Routine Description:

    Test azroles.dll

Arguments:

    argc - the number of command-line arguments.

    argv - an array of pointers to the arguments.

Return Value:

    Exit status

--*/
{
    BOOL RetVal = TRUE;

    DWORD WinStatus;
    DWORD ComState;

    ULONG TestNum;
    ULONG Index;
    ULONG Index2;
    CHAR EchoPrefix[1024];

    BOOLEAN TestFound;
    BOOLEAN ObjectTests;
    BOOLEAN ShareTests;
    BOOLEAN PersistTests;
    BOOLEAN AccessTests;
    BOOLEAN SidxTests;
    BOOLEAN CommonInit;
    BOOLEAN ManyScopes;
    BOOLEAN MultiAccessCheck;
    BOOLEAN MultiThread;
    BOOLEAN MultiLdap;
    BOOLEAN BizruleMod;
    BOOLEAN GroupMod;
    BOOLEAN UseThreadToken;
    BOOLEAN fPrintUsage = FALSE;
    BOOLEAN AvoidDefaults;

    LPSTR Argument;


    ULONG TestIndex;
    int ArgIndex;

    struct {
        LPSTR TestName;
        BOOLEAN *EnableIt;
        BOOLEAN IsDefault;
        BOOLEAN AvoidDefaults;
        LPSTR Description;
    } Tests[] = {
        { "/Object",      &ObjectTests,      TRUE,  TRUE,  "Run lots of tests on all objects" },
        { "/Share",       &ShareTests,       TRUE,  TRUE,  "Test name sharing" },
        { "/Persist",     &PersistTests,     TRUE,  TRUE,  "Test persistence" },
        { "/Access",      &AccessTests,      TRUE,  TRUE,  "Test AccessCheck" },
        { "/Sidx",        &SidxTests,        FALSE, TRUE,  "Test a group with *lots* of Sids" },
        { "/ManyScopes",  &ManyScopes,       FALSE, TRUE,  "Test creating *lots* of scopes" },
        { "/MultiAccess", &MultiAccessCheck, FALSE, TRUE,  "Test many AccessChecks in a loop" },
        { "/MultiThread", &MultiThread,      FALSE, TRUE,  "Test AccessCheck in multiple threads" },
        { "/MultiLdap",   &MultiLdap,        FALSE, TRUE,  "Test AccessCheck in multiple threads using LDAP query" },
        { "/BizruleMod",  &BizruleMod,       FALSE, TRUE,  "Test modifying a bizrule during AccessCheck" },
        { "/GroupMod",    &GroupMod,         FALSE, TRUE,  "Test modifying a group membership during AccessCheck" },
        { "/ThreadToken", &UseThreadToken,   FALSE, FALSE, "Use thread token for all access tests" },
        { "/NoInitAll",   &NoInitAllTests,   FALSE, FALSE, "Skip AzInitialize before AzDelete" },
        { "/NoUpdateCache", &NoUpdateCache,  FALSE, FALSE, "Skip AzUpdateCache on every operation" },
        { "/Silent",      &Silent,           FALSE, FALSE, "Be quieter to avoid affecting timing" },
    };
#define TEST_COUNT (sizeof(Tests)/sizeof(Tests[0]))

    //
    // Objects that are children of "AdminManager"
    //
    DWORD GenAdmChildTests[] =    {     AzoApp,        AzoGroup };
    LPSTR GenAdmChildTestName[] = {     "Application", "Group" };
    POPERATION SpeAdmChildTestOps[] = { OpApplication, OpAdmGroup };
    POPERATION GenAdmChildTestOps[] = { OpAdmChildGen, OpAdmChildGenDupName
#ifdef ENABLE_LEAK
        , OpAdmChildGenLeak
#endif // ENABLE_LEAK
    };

    //
    // Objects that are children of "Application"
    //
    DWORD GenAppChildTests[] =    {     AzoOp,       AzoTask, AzoScope, AzoGroup,   AzoRole };
    LPSTR GenAppChildTestName[] = {     "Operation", "Task",  "Scope",  "Group",    "Role" };
    POPERATION SpeAppChildTestOps[] = { OpOperation, OpAppTask, NULL,   OpAppGroup, OpAppRole };
    POPERATION GenAppChildTestOps[] = { OpAppChildGen, OpAppChildGenDupName };

    //
    // Objects that are children of "Scope"
    //
    DWORD GenScopeChildTests[] =    {     AzoGroup,    AzoRole,  AzoTask };
    LPSTR GenScopeChildTestName[] = {     "Group",     "Role",   "Task" };
    POPERATION SpeScopeChildTestOps[] = { OpScopeGroup, OpScopeRole, OpScopeTask };
    POPERATION GenScopeChildTestOps[] = { OpScopeChildGen, OpScopeChildGenDupName };


    struct {

        //
        // Name of the parent object
        LPSTR ParentName;

        //
        // List of children to test for this parent
        DWORD ChildCount;
        DWORD *ChildOpcodeOffsets;
        LPSTR *ChildTestNames;
        // Operation to perform that is specific to the child type
        POPERATION *ChildOperations;

        //
        // List of tests to perform for each child type
        //
        DWORD OperationCount;
        POPERATION *Operations;
    } ParentChildTests[] = {
        { "AdminManager",
           sizeof(GenAdmChildTestName)/sizeof(GenAdmChildTestName[0]),
           GenAdmChildTests,
           GenAdmChildTestName,
           SpeAdmChildTestOps,
           sizeof(GenAdmChildTestOps)/sizeof(GenAdmChildTestOps[0]),
           GenAdmChildTestOps },
        { "Application",
           sizeof(GenAppChildTestName)/sizeof(GenAppChildTestName[0]),
           GenAppChildTests,
           GenAppChildTestName,
           SpeAppChildTestOps,
           sizeof(GenAppChildTestOps)/sizeof(GenAppChildTestOps[0]),
           GenAppChildTestOps },
        { "Scope",
           sizeof(GenScopeChildTestName)/sizeof(GenScopeChildTestName[0]),
           GenScopeChildTests,
           GenScopeChildTestName,
           SpeScopeChildTestOps,
           sizeof(GenScopeChildTestOps)/sizeof(GenScopeChildTestOps[0]),
           GenScopeChildTestOps },
    };

    WinStatus = AzComInitialize( &ComState );

    if ( WinStatus != NO_ERROR ) {
        printf( "Cannot cominitialize %ld\n", WinStatus );
        RetVal = FALSE;
        goto Cleanup;
    }

    //
    // Assume no tests should be run
    //

    for ( TestIndex=0; TestIndex<TEST_COUNT; TestIndex++ ) {
        *(Tests[TestIndex].EnableIt) = FALSE;
    }


    if ( argc > 1 ) {

        Argument = argv[1];

        //
        // Is this XML or AD store testing?
        //

        if ( !_strcmpi( Argument, "-ad" ) ) {

#ifdef ENABLE_ADMIN_ACCOUNT_AD
            AzGlTestFile = L"msldap://CN=CliffV,OU=AzRoles,DC=cliffvdom,DC=nttest,DC=microsoft,DC=com";
#else // ENABLE_ADMIN_ACCOUNT_AD
            AzGlTestFile = L"msldap://CN=Chaitu,OU=AzRoles,DC=chaitu-dom3602,DC=nttest,DC=microsoft,DC=com";
#endif // ENABLE_ADMIN_ACCOUNT_AD

        } else if ( !_strcmpi( Argument, "-xml" ) ) {

            AzGlTestFile = L"msxml://.//TestFile.xml";
            // Delete the testfile
            DeleteFileW( L".\\TestFile.xml" );

        } else {

            fPrintUsage = TRUE;
            goto Usage;
        }

    } else {

        fPrintUsage = TRUE;
        goto Usage;

    }

    //
    // Parse the command line options
    //

    AvoidDefaults = FALSE;
    for ( ArgIndex=2; ArgIndex<argc; ArgIndex++ ) {

        Argument = argv[ArgIndex];

        //
        // Loop through the list of valid values
        //

        for ( TestIndex=0; TestIndex<TEST_COUNT; TestIndex++ ) {

            //
            // If found, set the boolean
            //
            if ( _strcmpi( Argument, Tests[TestIndex].TestName) == 0 ) {
                *(Tests[TestIndex].EnableIt) = TRUE;
                if ( Tests[TestIndex].AvoidDefaults ) {
                    AvoidDefaults = TRUE;
                }
                break;
            }

        }

        //
        // If typo,
        //  complain
        //

        if ( TestIndex >= TEST_COUNT ) {

            fPrintUsage = TRUE;
            goto Usage;
        }
    }

    //
    // If no options were specified,
    //  use the defaults.
    //

    if ( !AvoidDefaults ) {

        for ( TestIndex=0; TestIndex<TEST_COUNT; TestIndex++ ) {
            if ( Tests[TestIndex].IsDefault) {
                *(Tests[TestIndex].EnableIt) = TRUE;
            }
        }
    }

    //
    // Run the generic object tests
    //

    if ( ObjectTests ) {

        //
        // Do admin manager specific tests
        //
        if ( !DoOperations( OpAdm, 0, 0, "AdminManager" ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }


        //
        // Loop for each object that can be the parent of another object
        //

        for ( TestNum=0; TestNum < sizeof(ParentChildTests)/sizeof(ParentChildTests[0]); TestNum++ ) {

            //
            // Loop for each child of the parent object
            //
            for ( Index=0; Index < ParentChildTests[TestNum].ChildCount; Index ++ ) {

                //
                // output the test name
                //

                strcpy( EchoPrefix, ParentChildTests[TestNum].ParentName );
                strcat( EchoPrefix, "->" );
                strcat( EchoPrefix, ParentChildTests[TestNum].ChildTestNames[Index] );

                if ( !Silent ) {
                    printf("\n%s - Perform tests of '%s' objects that are children of '%s' objects\n",
                            EchoPrefix,
                            ParentChildTests[TestNum].ChildTestNames[Index],
                            ParentChildTests[TestNum].ParentName );
                }

                //
                // Do the various generic tests that apply to all objects
                //

                for ( Index2=0; Index2 < ParentChildTests[TestNum].OperationCount; Index2 ++ ) {

                    if ( !DoOperations(
                                ParentChildTests[TestNum].Operations[Index2],
                                0,
                                ParentChildTests[TestNum].ChildOpcodeOffsets[Index],
                                EchoPrefix ) ) {

                        RetVal = FALSE;
                        goto Cleanup;
                    }

                }

                //
                // Do the one test that is specific to this parent/child relationship
                //

                if ( ParentChildTests[TestNum].ChildOperations[Index] == NULL ) {
                    // ??? Should complain here.  Test is missing
                } else {

                    if ( !DoOperations(
                                ParentChildTests[TestNum].ChildOperations[Index],
                                0,
                                ParentChildTests[TestNum].ChildOpcodeOffsets[Index],
                                EchoPrefix ) ) {

                        RetVal = FALSE;
                        goto Cleanup;
                    }

                }
            }
        }
    }


    //
    // Do name sharing specific tests
    //
    if ( ShareTests ) {
        if ( !DoOperations( OpShare, 0, 0, "NameShare" ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }
    }

    //
    // Do peristence specific tests
    //
    if ( PersistTests ) {
        if ( !DoOperations( OpPersist, 0, 0, "Persist" ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }
    }

    //
    // Grab my token
    //

    if ( UseThreadToken ) {
        if ( !OpenProcessToken( GetCurrentProcess(),
                                TOKEN_QUERY | TOKEN_IMPERSONATE | TOKEN_DUPLICATE,
                                &TokenHandle ) ) {

            printf( "Cannot OpenProcessToken %ld\n", GetLastError() );
            RetVal = FALSE;
            goto Cleanup;
        }
    }


    //
    // Do AccessCheck specific tests
    //

    if ( AccessTests ) {

        if ( !DoOperations( OpAccess, 0, 0, "Access" ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }
    }

    //
    // Is this one of the tests that need common initialization?
    //

    CommonInit = FALSE;
    if ( SidxTests || ManyScopes || MultiAccessCheck || MultiThread || MultiLdap || BizruleMod || GroupMod ) {
        CommonInit = TRUE;

    }

    if ( CommonInit ) {

        if ( !DoOperations( OpAccessBegin, 0, 0, "AccessBegin" ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }
    }

    //
    // Create oodles of scope objects
    //

    if ( ManyScopes ) {
        DWORD OrigTicks;
        DWORD PrevTicks;
        DWORD Ticks;
        ULONG i;
        OrigTicks = GetTickCount();
        PrevTicks = OrigTicks;

        for ( i=0; i<10000; i++) {
            swprintf( ScopeBillions, L"Multi-Scope %ld", i );

            if ( !DoOperations( OpBillions, 0, 0, "Billions" ) ) {
                RetVal = FALSE;
                goto Cleanup;
            }

            Ticks = GetTickCount();
            printf( "%ld milliseconds\n", Ticks - PrevTicks );
            PrevTicks = Ticks;

        }
        printf( "%ld milliseconds\n", GetTickCount() - OrigTicks );
    }

    //
    // Test running access check in multiple threads
    //

    if ( MultiThread || MultiLdap ) {
        // Fire off another thread
        if ( !QueueUserWorkItem( AccessCheckThread, (PVOID)MultiLdap, 0 ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }
    }


    //
    // Fire off a thread to change the bizrule on a task being used to access check
    //
    if ( BizruleMod ) {
        if ( !QueueUserWorkItem( BizRuleChangeThread, NULL, 0 ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }
    }


    //
    // Fire off a thread to change a group being used to access check
    //
    if ( GroupMod ) {
        if ( !QueueUserWorkItem( GroupChangeThread, NULL, 0 ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }
    }

    //
    // Do the tests the are designed to conflict with the above ASYNC operations
    //
    if ( MultiAccessCheck || MultiThread || MultiLdap || BizruleMod || GroupMod ) {
        DWORD Ticks;
        ULONG i;
        Ticks = GetTickCount();
        for ( i=0; i<1000; i++ ) {
            if ( MultiLdap ) {
                if ( !DoOperations( OpAccess2Ldap, 0, 0, "Access2Ldap" ) ) {
                    RetVal = FALSE;
                    goto Cleanup;
                }
            } else {
                if ( !DoOperations( OpAccess2, 0, 0, "Access2" ) ) {
                    RetVal = FALSE;
                    goto Cleanup;
                }
            }

            // Sleep a bit to allow other thread a chance to run
            if ( !MultiAccessCheck ) {
                Sleep(20);
            }
        }
        Ticks = GetTickCount() - Ticks;
        printf( "%ld milliseconds\n", Ticks );
    }

    //
    // Create a group with a *lot* of sids
    //

    if ( SidxTests ) {
        ULONG i;
        PSID Sid = (PSID)SidX;
        SID_IDENTIFIER_AUTHORITY Ia = SECURITY_WORLD_SID_AUTHORITY;

        if ( !DoOperations( OpSidxBegin, 0, 0, "SidxBegin" ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }

        for ( i=0; i<1000; i++ ) {

            //
            // Add the everyone sid at an opportune spot
            //
            if ( i == 9999 ) {
#if 0
                RtlCopyMemory( Sid, &SidWorld, GetLengthSid( &SidWorld ) );
#else // 0
                RtlCopyMemory( Sid, &SidLocal, GetLengthSid( &SidLocal ) );
#endif // 0


            } else {
                DWORD j;

                //
                // Build a huge sid that no-one has
                //
#define AuthorityCount SID_MAX_SUB_AUTHORITIES
                if ( !InitializeSid( Sid, &Ia, AuthorityCount )) {
                    RetVal = FALSE;
                    goto Cleanup;
                }

                for ( j=0; j<AuthorityCount; j++ ) {
                    *GetSidSubAuthority( Sid, j ) = j+1;
                }

                // Set a different sid each time
                *GetSidSubAuthority( Sid, AuthorityCount-1) = i;
            }

            if ( !DoOperations( OpSidx, 0, 0, "Sidx" ) ) {
                RetVal = FALSE;
                goto Cleanup;
            }

        }

        if ( !DoOperations( OpSidxEnd, 0, 0, "SidxEnd" ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }

    }

    //
    // The common initialization requires common rundown
    //

    if ( CommonInit ) {

        if ( !DoOperations( OpAccessEnd, 0, 0, "AccessEnd" ) ) {
            RetVal = FALSE;
            goto Cleanup;
        }
    }

    //
    // print usage
    //

Usage:

    if ( fPrintUsage ) {

        fprintf( stderr, "Usage: aztest <store> [<options>]\n" );
        fprintf( stderr, "\nWhere <store> is:\n\n" );

        fprintf( stderr, "    -xml: Do XML provider testing\n" );
        fprintf( stderr, "    -ad : Do Active directory provider testing\n");

        fprintf( stderr, "\nAnd where <options> are:\n\n" );

        for ( TestIndex=0; TestIndex<TEST_COUNT; TestIndex++ ) {
            fprintf( stderr, "    %s - %s\n", Tests[TestIndex].TestName, Tests[TestIndex].Description );
        }

        fprintf( stderr, "\nIf no options are specified, the following are implied:\n\n    " );

        for ( TestIndex=0; TestIndex<TEST_COUNT; TestIndex++ ) {
            if ( Tests[TestIndex].IsDefault) {
                fprintf( stderr, "%s ", Tests[TestIndex].TestName );
            }
        }

        fprintf( stderr, "\n" );
        return 1;
    }

    //
    // Done
    //
Cleanup:
    AzComUninitialize( ComState );
    printf( "\n\n" );
    if ( RetVal ) {
        printf( "Tests completed successfully!\n");
        return 0;
    } else {
        printf( "One or more tests failed.\n");
        return 1;
    }

}