private void ProcessDelete(AdObject obj, bool returnObject = false)
    {
        ActiveDirectoryObjectResult result = new ActiveDirectoryObjectResult()
        {
            Type     = obj.Type,
            Identity = obj.Identity
        };

        ActiveDirectoryStatus status = new ActiveDirectoryStatus()
        {
            Action  = config.Action,
            Status  = AdStatusType.Success,
            Message = "Success",
        };

        try
        {
            roleManager.CanPerformActionOrException(requestUser, ActionType.Delete, obj.Identity);
            switch (obj.Type)
            {
            case AdObjectType.User:
                AdUser user = (AdUser)obj;
                DirectoryServices.DeleteUser(user.Identity);
                result.Statuses.Add(status);
                break;

            case AdObjectType.Group:
                AdGroup group = (AdGroup)obj;
                DirectoryServices.DeleteGroup(group.Identity, isDryRun);
                result.Statuses.Add(status);
                break;

            case AdObjectType.OrganizationalUnit:
                AdOrganizationalUnit ou = (AdOrganizationalUnit)obj;
                DirectoryServices.DeleteOrganizationUnit(ou.Identity);
                result.Statuses.Add(status);
                break;

            default:
                throw new AdException("Action [" + config.Action + "] Not Implemented For Type [" + obj.Type + "]", AdStatusType.NotSupported);
            }

            String message = $"{obj.Type} [{obj.Identity}] Deleted.";
            OnLogMessage("ProcessDelete", message);
        }
        catch (AdException ex)
        {
            ProcessActiveDirectoryException(result, ex, status.Action);
        }
        catch (Exception e)
        {
            OnLogMessage("ProcessDelete", e.Message);
            OnLogMessage("ProcessDelete", e.StackTrace);
            AdException le = new AdException(e);
            ProcessActiveDirectoryException(result, le, status.Action);
        }

        results.Add(result);
    }
        public static void DeleteGroup(string identity)
        {
            Console.WriteLine($"Deleting Group [{identity}]");
            DirectoryServices.DeleteGroup(identity);

            GroupPrincipalObject gpo = DirectoryServices.GetGroup(identity, false, false, false);

            Assert.That(gpo, Is.Null);
        }
        public void Core_DeleteGroupDoesNotExist()
        {
            // Get User That Does Not Exist
            String groupName = $"testgroup_{Utility.GenerateToken( 8 )}";
            String groupDistinguishedName = $"CN={groupName},{workspaceName}";

            Console.WriteLine($"Deleting Group [{groupDistinguishedName}] Which Should Not Exist.");
            AdException ex = Assert.Throws <AdException>(() => DirectoryServices.DeleteGroup(groupName));

            Console.WriteLine($"Exception Message : {ex.Message}");
            Assert.That(ex.Message, Contains.Substring("cannot be found"));
        }