public void can_get_timespan_with_custom_converter()
{
var collection = new Hashtable { { "length", "1:10:10" } };
var value = collection.Get("length", TimeSpan.Parse);
Expect(value, Is.EqualTo(TimeSpan.FromSeconds(4210)));
}
public void can_get_bool_from_hashtable()
{
var table = new Hashtable { { "app id", "true" } };
var value = table.Get<bool>("app id");
Expect(value, Is.True);
}
public void can_get_string_from_hashtable()
{
var table = new Hashtable { { "app id", "abc123" } };
var value = table.Get<string>("app id");
Expect(value, Is.EqualTo("abc123"));
}
public void get_bool_with_custom_converter_from_hashtable()
{
var table = new Hashtable { { "allow", "on" } };
var value = table.Get(
"allow",
v =>
{
bool allowed;
if (!bool.TryParse(v, out allowed))
{
allowed = v.Equals("on", StringComparison.Ordinal);
}
return allowed;
});
Expect(value, Is.True);
}
public void get_null_string_from_hashtable_for_missing_value()
{
var table = new Hashtable { { "app id", "abc123" } };
var value = table.Get<string>("cat id");
Expect(value, Is.Null);
}
public void get_false_from_hashtable_for_missing_value()
{
var table = new Hashtable { { "app id", "abc123" } };
var value = table.Get<bool>("Allow Windows Live Writer");
Expect(value, Is.False);
}
/// <summary>
/// This specialized method returns a Map of users and local groups for the
/// target server where keys are SIDs representing an account and each value
/// is an List<object> of SIDs represents the local groups that the account is
/// a member of.
/// </summary>
/// <remarks>
/// This specialized method returns a Map of users and local groups for the
/// target server where keys are SIDs representing an account and each value
/// is an List<object> of SIDs represents the local groups that the account is
/// a member of.
/// <p/>
/// This method is designed to assist with computing access control for a
/// given user when the target object's ACL has local groups. Local groups
/// are not listed in a user's group membership (e.g. as represented by the
/// tokenGroups constructed attribute retrived via LDAP).
/// <p/>
/// Domain groups nested inside a local group are currently not expanded. In
/// this case the key (SID) type will be SID_TYPE_DOM_GRP rather than
/// SID_TYPE_USER.
/// </remarks>
/// <param name="authorityServerName">The server from which the local groups will be queried.
/// </param>
/// <param name="auth">The credentials required to query groups and group members.</param>
/// <param name="flags">
/// Flags that control the behavior of the operation. When all
/// name associated with SIDs will be required, the SID_FLAG_RESOLVE_SIDS
/// flag should be used which causes all group member SIDs to be resolved
/// together in a single more efficient operation.
/// </param>
/// <exception cref="System.IO.IOException"></exception>
internal static Hashtable GetLocalGroupsMap(string authorityServerName, NtlmPasswordAuthentication
auth, int flags)
{
Sid domsid = GetServerSid(authorityServerName, auth);
DcerpcHandle handle = null;
SamrPolicyHandle policyHandle = null;
SamrDomainHandle domainHandle = null;
Samr.SamrSamArray sam = new Samr.SamrSamArray();
MsrpcEnumerateAliasesInDomain rpc;
lock (SidCache)
{
try
{
handle = DcerpcHandle.GetHandle("ncacn_np:" + authorityServerName + "[\\PIPE\\samr]"
, auth);
policyHandle = new SamrPolicyHandle(handle, authorityServerName, unchecked(0x02000000));
domainHandle = new SamrDomainHandle(handle, policyHandle, unchecked(0x02000000), domsid);
rpc = new MsrpcEnumerateAliasesInDomain(domainHandle, unchecked(0xFFFF), sam
);
handle.Sendrecv(rpc);
if (rpc.Retval != 0)
{
throw new SmbException(rpc.Retval, false);
}
Hashtable map = new Hashtable();
for (int ei = 0; ei < rpc.Sam.Count; ei++)
{
Samr.SamrSamEntry entry = rpc.Sam.Entries[ei];
Sid[] mems = GetGroupMemberSids0(handle, domainHandle, domsid
, entry.Idx, flags);
Sid groupSid = new Sid(domsid, entry.Idx);
groupSid.Type = SidTypeAlias;
groupSid.DomainName = domsid.GetDomainName();
groupSid.AcctName = (new UnicodeString(entry.Name, false)).ToString();
for (int mi = 0; mi < mems.Length; mi++)
{
List<object> groups = (List<object>)map.Get(mems[mi]);
if (groups == null)
{
groups = new List<object>();
map.Put(mems[mi], groups);
}
if (!groups.Contains(groupSid))
{
groups.Add(groupSid);
}
}
}
return map;
}
finally
{
if (handle != null)
{
if (policyHandle != null)
{
if (domainHandle != null)
{
domainHandle.Close();
}
policyHandle.Close();
}
handle.Close();
}
}
}
}
public bool Run()
{
for (int j = 0; j < numberOfDocuments; j++)
{
Document doc = docs[j];
SavedRevision lastSavedRevision = null;
for (int k = 0; k < numberOfUpdates; k++)
{
if (lastSavedRevision != null)
{
NUnit.Framework.Assert.AreEqual(lastSavedRevision.GetId(), doc.GetCurrentRevisionId
());
}
IDictionary<string, object> contents = new Hashtable(doc.GetProperties());
Document docLatest = this._enclosing.database.GetDocument(doc.GetId());
bool wasChecked = (bool)contents.Get("toogle");
contents.Put("toogle", !wasChecked);
try
{
lastSavedRevision = doc.PutProperties(contents);
numDocsUpdated.IncrementAndGet();
}
catch (CouchbaseLiteException cblex)
{
Log.E(LiteTestCase.Tag, "Document update failed", cblex);
numExceptions.IncrementAndGet();
}
}
}
return true;
}
/// <summary>https://github.com/couchbase/couchbase-lite-android/issues/220</summary>
/// <exception cref="System.Exception"></exception>
public virtual void TestMultiDocumentUpdate()
{
int numberOfDocuments = 10;
int numberOfUpdates = 10;
Document[] docs = new Document[numberOfDocuments];
for (int j = 0; j < numberOfDocuments; j++)
{
IDictionary<string, object> prop = new Dictionary<string, object>();
prop.Put("foo", "bar");
prop.Put("toogle", true);
Document document = CreateDocumentWithProperties(database, prop);
docs[j] = document;
}
AtomicInteger numDocsUpdated = new AtomicInteger(0);
AtomicInteger numExceptions = new AtomicInteger(0);
for (int j_1 = 0; j_1 < numberOfDocuments; j_1++)
{
Document doc = docs[j_1];
for (int k = 0; k < numberOfUpdates; k++)
{
IDictionary<string, object> contents = new Hashtable(doc.GetProperties());
bool wasChecked = (bool)contents.Get("toogle");
//toggle value of check property
contents.Put("toogle", !wasChecked);
try
{
doc.PutProperties(contents);
numDocsUpdated.IncrementAndGet();
}
catch (CouchbaseLiteException cblex)
{
Log.E(Tag, "Document update failed", cblex);
numExceptions.IncrementAndGet();
}
}
}
NUnit.Framework.Assert.AreEqual(numberOfDocuments * numberOfUpdates, numDocsUpdated
.Get());
NUnit.Framework.Assert.AreEqual(0, numExceptions.Get());
}