public void Test_Common()
{
EnumSet <RestrictionEnum> es = EnumSet <RestrictionEnum> .Create();
Assert.IsTrue(es.IsEmpty());
es.Include(null);
Assert.IsTrue(es.IsEmpty());
es.Include(RestrictionEnum.rnPrivacy, RestrictionEnum.rnLocked);
Assert.IsTrue(es.Contains(RestrictionEnum.rnPrivacy));
Assert.IsFalse(es.Contains(RestrictionEnum.rnNone));
Assert.IsFalse(es.IsEmpty());
es.Exclude(RestrictionEnum.rnPrivacy);
Assert.IsFalse(es.Contains(RestrictionEnum.rnPrivacy));
Assert.IsTrue(es.Contains(RestrictionEnum.rnLocked));
es = EnumSet <RestrictionEnum> .Create(RestrictionEnum.rnNone, RestrictionEnum.rnLocked);
Assert.IsTrue(es.Contains(RestrictionEnum.rnNone));
Assert.IsTrue(es.Contains(RestrictionEnum.rnLocked));
string test = es.ToString().Substring(64 - 8);
Assert.AreEqual("00000011", test);
// clone test
EnumSet <RestrictionEnum> copy = (EnumSet <RestrictionEnum>)es.Clone();
test = copy.ToString().Substring(64 - 8);
Assert.AreEqual("00000011", test);
// clear test
copy.Clear();
Assert.IsTrue(copy.IsEmpty());
//
EnumSet <RestrictionEnum> es2 = EnumSet <RestrictionEnum> .Create(RestrictionEnum.rnNone, RestrictionEnum.rnLocked);
Assert.IsTrue(es.Equals(es2));
Assert.IsFalse(es.Equals(null));
Assert.IsTrue(es.Contains(RestrictionEnum.rnLocked));
Assert.IsFalse(es.Contains(RestrictionEnum.rnPrivacy));
EnumSet <RestrictionEnum> es3 = EnumSet <RestrictionEnum> .Create(RestrictionEnum.rnLocked);
EnumSet <RestrictionEnum> es4 = es * es3;
Assert.IsTrue(es4.Contains(RestrictionEnum.rnLocked));
es = EnumSet <RestrictionEnum> .Create(RestrictionEnum.rnNone);
es2 = EnumSet <RestrictionEnum> .Create(RestrictionEnum.rnLocked);
Assert.IsTrue(es != es2);
es = es + es2;
es3 = EnumSet <RestrictionEnum> .Create(RestrictionEnum.rnNone, RestrictionEnum.rnLocked);
Assert.IsTrue(es.Equals(es3));
Assert.IsFalse(es3.ContainsAll(new RestrictionEnum[] {}));
Assert.IsTrue(es3.ContainsAll(RestrictionEnum.rnNone, RestrictionEnum.rnLocked));
Assert.IsFalse(es3.ContainsAll(RestrictionEnum.rnNone, RestrictionEnum.rnPrivacy));
Assert.IsFalse(es3.HasIntersect(new RestrictionEnum[] {}));
Assert.IsTrue(es3.HasIntersect(RestrictionEnum.rnNone, RestrictionEnum.rnPrivacy));
Assert.IsFalse(es3.HasIntersect(RestrictionEnum.rnPrivacy));
es = es - es2;
es3 = EnumSet <RestrictionEnum> .Create(RestrictionEnum.rnNone);
Assert.IsTrue(es == es3);
Assert.AreEqual("0000000000000000000000000000000000000000000000000000000000000001", es3.ToString());
Assert.AreNotEqual(0, es3.GetHashCode());
}
public RevisionInternal GetDocumentWithIDAndRev(string id, string rev, EnumSet<Database.TDContentOptions
> contentOptions)
{
RevisionInternal result = null;
string sql;
Cursor cursor = null;
try
{
cursor = null;
string cols = "revid, deleted, sequence";
if (!contentOptions.Contains(Database.TDContentOptions.TDNoBody))
{
cols += ", json";
}
if (rev != null)
{
sql = "SELECT " + cols + " FROM revs, docs WHERE docs.docid=? AND revs.doc_id=docs.doc_id AND revid=? LIMIT 1";
string[] args = new string[] { id, rev };
cursor = database.RawQuery(sql, args);
}
else
{
sql = "SELECT " + cols + " FROM revs, docs WHERE docs.docid=? AND revs.doc_id=docs.doc_id and current=1 and deleted=0 ORDER BY revid DESC LIMIT 1";
string[] args = new string[] { id };
cursor = database.RawQuery(sql, args);
}
if (cursor.MoveToNext())
{
if (rev == null)
{
rev = cursor.GetString(0);
}
bool deleted = (cursor.GetInt(1) > 0);
result = new RevisionInternal(id, rev, deleted, this);
result.SetSequence(cursor.GetLong(2));
if (!contentOptions.Equals(EnumSet.Of(Database.TDContentOptions.TDNoBody)))
{
byte[] json = null;
if (!contentOptions.Contains(Database.TDContentOptions.TDNoBody))
{
json = cursor.GetBlob(3);
}
ExpandStoredJSONIntoRevisionWithAttachments(json, result, contentOptions);
}
}
}
catch (SQLException e)
{
Log.E(Database.Tag, "Error getting document with id and rev", e);
}
finally
{
if (cursor != null)
{
cursor.Close();
}
}
return result;
}
public override bool Equals(object that)
{
return(this == that || that is WorkLog && TransactionsConflict.Equals((( WorkLog )that).TransactionsConflict));
}
