public void testClear()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
loose = toList(master);
RefMap map = new RefMap("", packed, loose, resolved);
Assert.AreSame(master, map.get("refs/heads/master"));
map.clear();
Assert.IsNull(map.get("refs/heads/master"));
Assert.IsTrue(map.isEmpty());
Assert.AreEqual(0, map.size());
}
public void testClear()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
loose = toList(master);
RefMap map = new RefMap("", packed, loose, resolved);
Assert.AreSame(master, map.get("refs/heads/master"));
map.clear();
Assert.IsNull(map.get("refs/heads/master"));
Assert.IsTrue(map.isEmpty());
Assert.AreEqual(0, map.size());
}
public void testAddToEndOfList()
{
RefList <global::GitSharp.Core.Ref> one = toList(REF_A);
RefList <global::GitSharp.Core.Ref> two = one.add(1, REF_B);
Assert.AreNotSame(one, two);
// one is not modified, but two is
Assert.AreEqual(1, one.size());
Assert.AreSame(REF_A, one.get(0));
Assert.AreEqual(2, two.size());
Assert.AreSame(REF_A, two.get(0));
Assert.AreSame(REF_B, two.get(1));
}
public void testToString()
{
var exp = new StringBuilder();
exp.Append("[");
exp.Append(REF_A);
exp.Append(", ");
exp.Append(REF_B);
exp.Append("]");
RefList <global::GitSharp.Core.Ref> list = toList(REF_A, REF_B);
Assert.AreEqual(exp.ToString(), list.ToString());
}
/// <exception cref="System.IO.IOException"></exception>
public override IDictionary <string, Ref> GetRefs(string prefix)
{
RefList <Ref> packed = GetPackedRefs();
RefList <RefDirectory.LooseRef> oldLoose = looseRefs.Get();
RefDirectory.LooseScanner scan = new RefDirectory.LooseScanner(this, oldLoose);
scan.Scan(prefix);
RefList <RefDirectory.LooseRef> loose;
if (scan.newLoose != null)
{
scan.newLoose.Sort();
loose = scan.newLoose.ToRefList();
if (looseRefs.CompareAndSet(oldLoose, loose))
{
modCnt.IncrementAndGet();
}
}
else
{
loose = oldLoose;
}
FireRefsChanged();
RefListBuilder <Ref> symbolic = scan.symbolic;
for (int idx = 0; idx < symbolic.Size();)
{
Ref symbolicRef = symbolic.Get(idx);
Ref resolvedRef = Resolve(symbolicRef, 0, prefix, loose, packed);
if (resolvedRef != null && resolvedRef.GetObjectId() != null)
{
symbolic.Set(idx, resolvedRef);
idx++;
}
else
{
// A broken symbolic reference, we have to drop it from the
// collections the client is about to receive. Should be a
// rare occurrence so pay a copy penalty.
symbolic.Remove(idx);
int toRemove = loose.Find(symbolicRef.GetName());
if (0 <= toRemove)
{
loose = loose.Remove(toRemove);
}
}
}
symbolic.Sort();
return(new RefMap(prefix, packed, Upcast(loose), symbolic.ToRefList()));
}
public void testEmpty_WithPrefix()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
packed = toList(master);
RefMap map = new RefMap("refs/tags/", packed, loose, resolved);
Assert.IsTrue(map.isEmpty()); // before size was computed
Assert.AreEqual(0, map.size());
Assert.IsTrue(map.isEmpty()); // after size was computed
Assert.IsFalse(map.entrySet().iterator().hasNext());
Assert.IsFalse(map.keySet().iterator().hasNext());
}
/// <exception cref="System.IO.IOException"></exception>
private Ref Resolve(Ref @ref, int depth, string prefix, RefList <RefDirectory.LooseRef
> loose, RefList <Ref> packed)
{
if (@ref.IsSymbolic())
{
Ref dst = @ref.GetTarget();
if (MAX_SYMBOLIC_REF_DEPTH <= depth)
{
return(null);
}
// claim it doesn't exist
// If the cached value can be assumed to be current due to a
// recent scan of the loose directory, use it.
if (loose != null && dst.GetName().StartsWith(prefix))
{
int idx;
if (0 <= (idx = loose.Find(dst.GetName())))
{
dst = loose.Get(idx);
}
else
{
if (0 <= (idx = packed.Find(dst.GetName())))
{
dst = packed.Get(idx);
}
else
{
return(@ref);
}
}
}
else
{
dst = ReadRef(dst.GetName(), packed);
if (dst == null)
{
return(@ref);
}
}
dst = Resolve(dst, depth + 1, prefix, loose, packed);
if (dst == null)
{
return(null);
}
return(new SymbolicRef(@ref.GetName(), dst));
}
return(@ref);
}
public static Parameter[] SetPositionsFromLinearAddress(this RefList <Parameter> parameters, long linearAddress)
{
var newParameters = parameters.ToArray();
for (int i = parameters.Count - 1; i >= 1; i--)
{
var steps = parameters[i].Steps;
var tmp = linearAddress / steps;
var iPos = checked ((int)(linearAddress - tmp * steps));
newParameters[i].CurrentPosition = iPos;
linearAddress = tmp;
}
newParameters[0].CurrentPosition = checked ((int)linearAddress);
return(newParameters);
}
internal RefDirectory(FileRepository db)
{
//$NON-NLS-1$
//$NON-NLS-1$
//$NON-NLS-1$
FS fs = db.FileSystem;
parent = db;
gitDir = db.Directory;
logWriter = new ReflogWriter(db);
refsDir = fs.Resolve(gitDir, Constants.R_REFS);
packedRefsFile = fs.Resolve(gitDir, Constants.PACKED_REFS);
looseRefs.Set(RefList.EmptyList <RefDirectory.LooseRef>());
packedRefs.Set(RefDirectory.PackedRefList.NO_PACKED_REFS);
}
public override int Read(byte[] reference, int indexOf_second, int sum_util)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (workerInstance == null)
{
workerInstance = _0001(_GetterInstance);
}
if (m_PublisherInstance != -1)
{
CheckError(m_PublisherInstance);
}
int num = 0;
if (_ParamInstance > 0)
{
num += LoginError(reference, indexOf_second, sum_util - num);
}
while (num < sum_util)
{
workerInstance._0001(-3, 0, out int _, out CrashDumpGrbit connection, out ulong _, out DefinitionDic pol);
if ((connection & (CrashDumpGrbit)2) != 0)
{
break;
}
if ((connection & (CrashDumpGrbit)32) != 0)
{
_SystemInstance = CallDic(workerInstance);
DisableError();
}
else if (connection != 0)
{
throw new InvalidOperationException($"MediaFoundationReadError {connection}");
}
pol._0001(out InvocationDic info);
info._0001(out IntPtr v, out int _, out int dir);
RevertDic(dir);
Marshal.Copy(v, _RulesInstance, 0, dir);
_ContextInstance = 0;
_ParamInstance = dir;
num += LoginError(reference, indexOf_second + num, sum_util - num);
info._0001();
Marshal.ReleaseComObject(info);
Marshal.ReleaseComObject(pol);
}
advisorInstance += num;
return(num);
}
public MagicEffect(Cursor cursor) : base(cursor)
{
FullName = new StringField("FULL - Name", cursor);
MenuDisplayObject = new RefField <StaticObject>("MDOB", cursor);
ActorValue = new EnumField <ActorValue>("Magic Effect Data\\DATA - Data\\Actor Value", cursor);
Keywords = new RefList <Keyword>("KWDA", cursor);
Flags = new EnumField <MagicEffectFlags>("Magic Effect Data\\DATA\\Flags", cursor);
BaseCost = new FloatField("Magic Effect Data\\DATA\\Base Cost", cursor);
RelatedItem = new RefField <RecordBase>("Magic Effect Data\\DATA\\Assoc. Item", cursor);
MagicSkill = new EnumField <ActorValue>("Magic Effect Data\\DATA\\Magic Skill", cursor);
ResistValue = new EnumField <ActorValue>("Magic Effect Data\\DATA\\Resist Value", cursor);
Archtype = new EnumField <MagicEffectArchType>("Magic Effect Data\\DATA\\Archtype", cursor);
Description = new StringField("DNAM", cursor);
}
public void testPut_CollapseResolved()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
global::GitSharp.Core.Ref headU = newRef("HEAD", "refs/heads/master");
global::GitSharp.Core.Ref headR = newRef("HEAD", master);
global::GitSharp.Core.Ref a = newRef("refs/heads/A", ID_ONE);
loose = toList(headU, master);
resolved = toList(headR);
RefMap map = new RefMap("", packed, loose, resolved);
Assert.IsNull(map.put(a.getName(), a));
Assert.AreSame(a, map.get(a.getName()));
Assert.AreSame(headR, map.get("HEAD"));
}
internal MemberSet(Type type)
{
const BindingFlags PublicInstance = BindingFlags.Public | BindingFlags.Instance;
#if NET20
RefList <MemberInfo> properties = new RefList <MemberInfo>(type.GetProperties(PublicInstance));
properties.AddRange(new RefList <MemberInfo>(type.GetFields(PublicInstance)));
properties.Sort((p1, p2) => p1.Name.CompareTo(p2.Name));
members = properties.ConvertAll <Member>(mi => new Member(mi)).ToArray();
#else
members = type.GetProperties(PublicInstance).Cast <MemberInfo>()
.Concat(type.GetFields(PublicInstance).Cast <MemberInfo>())
.OrderBy(x => Marshal.OffsetOf(type, x.Name).ToInt32())
.Select(member => new Member(member)).ToArray();
#endif
}
public void testRemoveEndOfList()
{
RefList <global::GitSharp.Core.Ref> one = toList(REF_A, REF_B, REF_c);
RefList <global::GitSharp.Core.Ref> two = one.remove(2);
Assert.AreNotSame(one, two);
Assert.AreEqual(3, one.size());
Assert.AreSame(REF_A, one.get(0));
Assert.AreSame(REF_B, one.get(1));
Assert.AreSame(REF_c, one.get(2));
Assert.AreEqual(2, two.size());
Assert.AreSame(REF_A, two.get(0));
Assert.AreSame(REF_B, two.get(1));
}
public void testBuilder_ToString()
{
var exp = new StringBuilder();
exp.Append("[");
exp.Append(REF_A);
exp.Append(", ");
exp.Append(REF_B);
exp.Append("]");
var list = new RefList <global::GitSharp.Core.Ref> .Builder <global::GitSharp.Core.Ref>();
list.add(REF_A);
list.add(REF_B);
Assert.AreEqual(exp.ToString(), list.ToString());
}
public void testCopyLeadingPrefix()
{
RefList <global::GitSharp.Core.Ref> one = toList(REF_A, REF_B, REF_c);
RefList <global::GitSharp.Core.Ref> two = one.copy(2).toRefList();
Assert.AreNotSame(one, two);
Assert.AreEqual(3, one.size());
Assert.AreSame(REF_A, one.get(0));
Assert.AreSame(REF_B, one.get(1));
Assert.AreSame(REF_c, one.get(2));
Assert.AreEqual(2, two.size());
Assert.AreSame(REF_A, two.get(0));
Assert.AreSame(REF_B, two.get(1));
}
/// <exception cref="System.IO.IOException"></exception>
private Ref ReadRef(string name, RefList <Ref> packed)
{
RefList <RefDirectory.LooseRef> curList = looseRefs.Get();
int idx = curList.Find(name);
if (0 <= idx)
{
RefDirectory.LooseRef o = curList.Get(idx);
RefDirectory.LooseRef n = ScanRef(o, name);
if (n == null)
{
if (looseRefs.CompareAndSet(curList, curList.Remove(idx)))
{
modCnt.IncrementAndGet();
}
return(packed.Get(name));
}
if (o == n)
{
return(n);
}
if (looseRefs.CompareAndSet(curList, curList.Set(idx, n)))
{
modCnt.IncrementAndGet();
}
return(n);
}
RefDirectory.LooseRef n_1 = ScanRef(null, name);
if (n_1 == null)
{
return(packed.Get(name));
}
// check whether the found new ref is the an additional ref. These refs
// should not go into looseRefs
for (int i = 0; i < additionalRefsNames.Length; i++)
{
if (name.Equals(additionalRefsNames[i]))
{
return(n_1);
}
}
if (looseRefs.CompareAndSet(curList, curList.Add(idx, n_1)))
{
modCnt.IncrementAndGet();
}
return(n_1);
}
public override IDictionary <string, Ref> getRefs(string prefix)
{
RefList <Ref> packed = getPackedRefs();
RefList <LooseRef> oldLoose = looseRefs.get();
var scan = new LooseScanner(oldLoose, this);
scan.scan(prefix);
RefList <LooseRef> loose;
if (scan.newLoose != null)
{
loose = scan.newLoose.toRefList();
if (looseRefs.compareAndSet(oldLoose, loose))
{
modCnt.incrementAndGet();
}
}
else
{
loose = oldLoose;
}
fireRefsChanged();
RefList <Ref> .Builder <Ref> symbolic = scan.symbolic;
for (int idx = 0; idx < symbolic.size();)
{
Ref @ref = symbolic.get(idx);
@ref = resolve(@ref, 0, prefix, loose, packed);
if (@ref != null && @ref.getObjectId() != null)
{
symbolic.set(idx, @ref);
idx++;
}
else
{
// A broken symbolic reference, we have to drop it from the
// collections the client is about to receive. Should be a
// rare occurrence so pay a copy penalty.
loose = loose.remove(idx);
symbolic.remove(idx);
}
}
return(new RefMap(prefix, packed, upcast(loose), symbolic.toRefList()));
}
public override Ref getRef(string needle)
{
RefList <Ref> packed = getPackedRefs();
Ref @ref = null;
foreach (string prefix in SEARCH_PATH)
{
@ref = readRef(prefix + needle, packed);
if (@ref != null)
{
@ref = resolve(@ref, 0, null, null, packed);
break;
}
}
fireRefsChanged();
return(@ref);
}
public void testPutNewEntry()
{
RefList <global::GitSharp.Core.Ref> one = toList(REF_A, REF_c);
RefList <global::GitSharp.Core.Ref> two = one.put(REF_B);
Assert.AreNotSame(one, two);
// one is not modified, but two is
Assert.AreEqual(2, one.size());
Assert.AreSame(REF_A, one.get(0));
Assert.AreSame(REF_c, one.get(1));
Assert.AreEqual(3, two.size());
Assert.AreSame(REF_A, two.get(0));
Assert.AreSame(REF_B, two.get(1));
Assert.AreSame(REF_c, two.get(2));
}
public override Ref peel(Ref @ref)
{
Ref leaf = @ref.getLeaf();
if (leaf.isPeeled() || leaf.getObjectId() == null)
{
return(@ref);
}
RevWalk.RevWalk rw = new RevWalk.RevWalk(getRepository());
RevObject obj = rw.parseAny(leaf.getObjectId());
ObjectIdRef newLeaf;
if (obj is RevTag)
{
do
{
obj = rw.parseAny(((RevTag)obj).getObject());
} while (obj is RevTag);
newLeaf = new PeeledTag(leaf.getStorage(), leaf
.getName(), leaf.getObjectId(), obj.Copy());
}
else
{
newLeaf = new PeeledNonTag(leaf.getStorage(), leaf
.getName(), leaf.getObjectId());
}
// Try to remember this peeling in the cache, so we don't have to do
// it again in the future, but only if the reference is unchanged.
if (leaf.getStorage().IsLoose)
{
RefList <LooseRef> curList = looseRefs.get();
int idx = curList.find(leaf.getName());
if (0 <= idx && curList.get(idx) == leaf)
{
LooseRef asPeeled = ((LooseRef)leaf).peel(newLeaf);
RefList <LooseRef> newList = curList.set(idx, asPeeled);
looseRefs.compareAndSet(curList, newList);
}
}
return(recreate(@ref, newLeaf));
}
public void scan(string prefix)
{
if (ALL.Equals(prefix))
{
scanOne(Constants.HEAD);
scanTree(Constants.R_REFS, _refDirectory.refsDir);
// If any entries remain, they are deleted, drop them.
if (newLoose == null && curIdx < curLoose.size())
{
newLoose = curLoose.copy(curIdx);
}
}
else if (prefix.StartsWith(Constants.R_REFS) && prefix.EndsWith("/"))
{
curIdx = -(curLoose.find(prefix) + 1);
DirectoryInfo dir = PathUtil.CombineDirectoryPath(_refDirectory.refsDir, prefix.Substring(Constants.R_REFS.Length));
scanTree(prefix, dir);
// Skip over entries still within the prefix; these have
// been removed from the directory.
while (curIdx < curLoose.size())
{
if (!curLoose.get(curIdx).getName().StartsWith(prefix))
{
break;
}
if (newLoose == null)
{
newLoose = curLoose.copy(curIdx);
}
curIdx++;
}
// Keep any entries outside of the prefix space, we
// do not know anything about their status.
if (newLoose != null)
{
while (curIdx < curLoose.size())
{
newLoose.add(curLoose.get(curIdx++));
}
}
}
}
public void testBuilder_AddThenSort()
{
var builder = new RefList <global::GitSharp.Core.Ref> .Builder <global::GitSharp.Core.Ref>(1);
builder.add(REF_B);
builder.add(REF_A);
RefList <global::GitSharp.Core.Ref> list = builder.toRefList();
Assert.AreEqual(2, list.size());
Assert.AreSame(REF_B, list.get(0));
Assert.AreSame(REF_A, list.get(1));
builder.sort();
list = builder.toRefList();
Assert.AreEqual(2, list.size());
Assert.AreSame(REF_A, list.get(0));
Assert.AreSame(REF_B, list.get(1));
}
public override RefUpdate newUpdate(string name, bool detach)
{
RefList <Ref> packed = getPackedRefs();
Ref @ref = readRef(name, packed);
if (@ref != null)
{
@ref = resolve(@ref, 0, null, null, packed);
}
if (@ref == null)
{
@ref = new Unpeeled(Storage.New, name, null);
}
else if (detach && @ref.isSymbolic())
{
@ref = new Unpeeled(Storage.Loose, name, @ref.getObjectId());
}
return(new RefDirectoryUpdate(this, @ref));
}
public void testPutReplaceEntry()
{
global::GitSharp.Core.Ref otherc = newRef(REF_c.Name);
Assert.AreNotSame(REF_c, otherc);
RefList <global::GitSharp.Core.Ref> one = toList(REF_A, REF_c);
RefList <global::GitSharp.Core.Ref> two = one.put(otherc);
Assert.AreNotSame(one, two);
// one is not modified, but two is
Assert.AreEqual(2, one.size());
Assert.AreSame(REF_A, one.get(0));
Assert.AreSame(REF_c, one.get(1));
Assert.AreEqual(2, two.size());
Assert.AreSame(REF_A, two.get(0));
Assert.AreSame(otherc, two.get(1));
}
public void testToString_NoPrefix()
{
global::GitSharp.Core.Ref a = newRef("refs/heads/A", ID_ONE);
global::GitSharp.Core.Ref b = newRef("refs/heads/B", ID_TWO);
packed = toList(a, b);
StringBuilder exp = new StringBuilder();
exp.Append("[");
exp.Append(a.ToString());
exp.Append(", ");
exp.Append(b.ToString());
exp.Append("]");
RefMap map = new RefMap("", packed, loose, resolved);
Assert.AreEqual(exp.ToString(), map.ToString());
}
public void testEntryType()
{
global::GitSharp.Core.Ref a = newRef("refs/heads/A", ID_ONE);
global::GitSharp.Core.Ref b = newRef("refs/heads/B", ID_TWO);
packed = toList(a, b);
RefMap map = new RefMap("refs/heads/", packed, loose, resolved);
IteratorBase <RefMap.Ent> itr = map.entrySet().iterator();
RefMap.Ent ent_a = itr.next();
RefMap.Ent ent_b = itr.next();
Assert.AreEqual(ent_a.GetHashCode(), "A".GetHashCode());
Assert.IsTrue(ent_a.Equals(ent_a));
Assert.IsFalse(ent_a.Equals(ent_b));
Assert.AreEqual(a.ToString(), ent_a.ToString());
}
public DicInstanceRule(Stream last, RefList cust)
{
//Discarded unreachable code: IL_0002, IL_0006
//IL_0003: Incompatible stack heights: 0 vs 1
//IL_0007: Incompatible stack heights: 0 vs 1
SingletonReader.PushGlobal();
m_InterpreterInstance = new byte[3];
base._002Ector();
_ProducerInstance = last;
m_CustomerInstance = cust;
_StructInstance = new BinaryWriter(last, Encoding.UTF8);
_StructInstance.Write(Encoding.UTF8.GetBytes("RIFF"));
_StructInstance.Write(0);
_StructInstance.Write(Encoding.UTF8.GetBytes("WAVE"));
_StructInstance.Write(Encoding.UTF8.GetBytes("fmt "));
cust._0001(_StructInstance);
InvokeDic();
ConcatDic();
}
public BasePNRDataItem(BasePNRDataItem item)
{
Type = item.Type;
if (item.ServiceRef != null && item.ServiceRef.Count > 0)
{
ServiceRef = new RefList <int>(item.ServiceRef);
}
if (item.SegmentRef != null && item.SegmentRef.Count > 0)
{
SegmentRef = new RefList <int>(item.SegmentRef);
}
if (item.TravellerRef != null && item.TravellerRef.Count > 0)
{
TravellerRef = new RefList <int>(item.TravellerRef);
}
}
/// <summary>
/// Picking the best choice between <paramref name="p_choices"/>.
/// The choice is made by associating a score to every choices. The choice with the highest score is picked.
/// </summary>
/// <param name="p_choices"> Compared choices. </param>
/// <returns> The picked choice </returns>
public static ref AIDecisionTreeChoice defaultTestPickChoice(RefList <AIDecisionTreeChoice> p_choices, Entity p_calledEntity)
{
// Becuase PathScore represents the distance crossed and that we want to minimize movement,
// we normalize the PathScore by it's potential maxmimum value calculated if the Entity were using all it's ActionPoints to move.
ActionPoint l_calledEntityActionPoint = EntityComponent.get_component <ActionPoint>(p_calledEntity);
float l_maxPathScoreThatCanBeCrossed = _ActionPoint.Calculations.actionPointToCrossableWorldDistance(l_calledEntityActionPoint.ActionPointData.CurrentActionPoints);
RefList <AIDecisionScore> l_choiceScores = new RefList <AIDecisionScore>(p_choices.Count);
for (int i = 0; i < p_choices.Count; i++)
{
AIDecisionScore l_choiceScore = AIDecisionScore.build();
ref AIDecisionTreeChoice l_aIDecisionTreeChoice = ref p_choices.ValueRef(i);
for (int j = 0; j < l_aIDecisionTreeChoice.DecisionNodesChoiceOrdered.Length; j++)
{
switch (l_aIDecisionTreeChoice.DecisionNodesChoiceOrdered[j])
{
case MoveToNavigationNodeNode l_moveToNavigationNodeNode:
{
l_choiceScore.PathScore += math.max(l_maxPathScoreThatCanBeCrossed - l_moveToNavigationNodeNode.PathCost, 0.0f);
break;
}
case AttackNode l_attackNode:
{
l_choiceScore.DamageScore += l_attackNode.DamageDone;
break;
}
case HealNode l_healNode:
{
l_choiceScore.HealScore += l_healNode.RecoveredHealth;
break;
}
}
}
l_choiceScores.AddRef(ref l_choiceScore);
}
protected void filter()
{
string languageValue = ddlFilterLanguage.SelectedValue;
string refValue = ddlFilterReferanceType.SelectedValue;
if (languageValue != "0" && refValue != "0")
{
Language language = (from l in db.Language
where l.LanguageName == languageValue
select l).FirstOrDefault();
RefList.DataSource = (from r in db.Referance
where r.LanguageID == language.ID &&
r.ReferanceType == refValue
select r).ToList();
RefList.DataBind();
}
else if (languageValue != "0" && refValue == "0")
{
Language language = (from l in db.Language
where l.LanguageName == languageValue
select l).FirstOrDefault();
RefList.DataSource = (from r in db.Referance
where r.LanguageID == language.ID
select r).ToList();
RefList.DataBind();
}
else if (languageValue == "0" && refValue != "0")
{
RefList.DataSource = (from r in db.Referance
where r.ReferanceType == refValue
select r).ToList();
RefList.DataBind();
}
else
{
RefList.DataSource = (from r in db.Referance
select r).ToList();
RefList.DataBind();
}
}
public void testEmptyBuilder()
{
RefList<global::GitSharp.Core.Ref> list = new RefList<global::GitSharp.Core.Ref>.Builder<global::GitSharp.Core.Ref>().toRefList();
Assert.AreEqual(0, list.size());
Assert.IsFalse(list.iterator().hasNext());
Assert.AreEqual(-1, list.find("a"));
Assert.AreEqual(-1, list.find("z"));
Assert.IsFalse(list.contains("a"));
Assert.IsNull(list.get("a"));
Assert.IsTrue(list.asList().Count == 0);
Assert.AreEqual("[]", list.ToString());
// default array capacity should be 16, with no bounds checking.
Assert.IsNull(list.get(16 - 1));
try
{
list.get(16);
Assert.Fail("default RefList should have 16 element array");
}
catch (IndexOutOfRangeException)
{
// expected
}
}
public void testEmpty_WithPrefix()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
packed = toList(master);
RefMap map = new RefMap("refs/tags/", packed, loose, resolved);
Assert.IsTrue(map.isEmpty()); // before size was computed
Assert.AreEqual(0, map.size());
Assert.IsTrue(map.isEmpty()); // after size was computed
Assert.IsFalse(map.entrySet().iterator().hasNext());
Assert.IsFalse(map.keySet().iterator().hasNext());
}
public void testIterator_FailsAtEnd()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
loose = toList(master);
RefMap map = new RefMap("", packed, loose, resolved);
IteratorBase<global::GitSharp.Core.Ref> itr = map.values().iterator();
Assert.IsTrue(itr.hasNext());
Assert.AreSame(master, itr.next());
try
{
itr.next();
Assert.Fail("iterator allowed next");
}
catch (IndexOutOfRangeException)
{
// expected
}
}
public virtual void TestMerge_HeadMaster()
{
Ref master = NewRef("refs/heads/master", ID_ONE);
Ref headU = NewRef("HEAD", "refs/heads/master");
Ref headR = NewRef("HEAD", master);
loose = ToList(headU, master);
resolved = ToList(headR);
RefMap map = new RefMap(string.Empty, packed, loose, resolved);
NUnit.Framework.Assert.AreEqual(2, map.Count);
NUnit.Framework.Assert.IsFalse(map.IsEmpty());
NUnit.Framework.Assert.IsTrue(map.ContainsKey("refs/heads/master"));
NUnit.Framework.Assert.AreSame(master, map.Get("refs/heads/master"));
// resolved overrides loose given same name
NUnit.Framework.Assert.AreSame(headR, map.Get("HEAD"));
Iterator<Ref> itr = map.Values.Iterator();
NUnit.Framework.Assert.IsTrue(itr.HasNext());
NUnit.Framework.Assert.AreSame(headR, itr.Next());
NUnit.Framework.Assert.IsTrue(itr.HasNext());
NUnit.Framework.Assert.AreSame(master, itr.Next());
NUnit.Framework.Assert.IsFalse(itr.HasNext());
}
public void testMerge_WithPrefix()
{
global::GitSharp.Core.Ref a = newRef("refs/heads/A", ID_ONE);
global::GitSharp.Core.Ref b = newRef("refs/heads/foo/bar/B", ID_TWO);
global::GitSharp.Core.Ref c = newRef("refs/heads/foo/rab/C", ID_TWO);
global::GitSharp.Core.Ref g = newRef("refs/heads/g", ID_ONE);
packed = toList(a, b, c, g);
RefMap map = new RefMap("refs/heads/foo/", packed, loose, resolved);
Assert.AreEqual(2, map.size());
Assert.AreSame(b, map.get("bar/B"));
Assert.AreSame(c, map.get("rab/C"));
Assert.IsNull(map.get("refs/heads/foo/bar/B"));
Assert.IsNull(map.get("refs/heads/A"));
Assert.IsTrue(map.containsKey("bar/B"));
Assert.IsTrue(map.containsKey("rab/C"));
Assert.IsFalse(map.containsKey("refs/heads/foo/bar/B"));
Assert.IsFalse(map.containsKey("refs/heads/A"));
IteratorBase<RefMap.Ent> itr = map.entrySet().iterator();
RefMap.Ent ent;
Assert.IsTrue(itr.hasNext());
ent = itr.next();
Assert.AreEqual("bar/B", ent.getKey());
Assert.AreSame(b, ent.getValue());
Assert.IsTrue(itr.hasNext());
ent = itr.next();
Assert.AreEqual("rab/C", ent.getKey());
Assert.AreSame(c, ent.getValue());
Assert.IsFalse(itr.hasNext());
}
public void testMerge_HeadMaster()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
global::GitSharp.Core.Ref headU = newRef("HEAD", "refs/heads/master");
global::GitSharp.Core.Ref headR = newRef("HEAD", master);
loose = toList(headU, master);
resolved = toList(headR);
RefMap map = new RefMap("", packed, loose, resolved);
Assert.AreEqual(2, map.size());
Assert.IsFalse(map.isEmpty());
Assert.IsTrue(map.containsKey("refs/heads/master"));
Assert.AreSame(master, map.get("refs/heads/master"));
// resolved overrides loose given same name
Assert.AreSame(headR, map.get("HEAD"));
IteratorBase<global::GitSharp.Core.Ref> itr = map.values().iterator();
Assert.IsTrue(itr.hasNext());
Assert.AreSame(headR, itr.next());
Assert.IsTrue(itr.hasNext());
Assert.AreSame(master, itr.next());
Assert.IsFalse(itr.hasNext());
}
public void testIterator_MissingUnresolvedSymbolicRefIsBug()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
global::GitSharp.Core.Ref headR = newRef("HEAD", master);
loose = toList(master);
// loose should have added newRef("HEAD", "refs/heads/master")
resolved = toList(headR);
var map = new RefMap("", packed, loose, resolved);
IteratorBase<global::GitSharp.Core.Ref> itr = map.values().iterator();
try
{
itr.hasNext();
Assert.Fail("iterator did not catch bad input");
}
catch (InvalidOperationException err)
{
// expected
}
}
public virtual void TestToString_WithPrefix()
{
Ref a = NewRef("refs/heads/A", ID_ONE);
Ref b = NewRef("refs/heads/foo/B", ID_TWO);
Ref c = NewRef("refs/heads/foo/C", ID_TWO);
Ref g = NewRef("refs/heads/g", ID_ONE);
packed = ToList(a, b, c, g);
StringBuilder exp = new StringBuilder();
exp.Append("[");
exp.Append(b.ToString());
exp.Append(", ");
exp.Append(c.ToString());
exp.Append("]");
RefMap map = new RefMap("refs/heads/foo/", packed, loose, resolved);
NUnit.Framework.Assert.AreEqual(exp.ToString(), map.ToString());
}
public virtual void TestToString_NoPrefix()
{
Ref a = NewRef("refs/heads/A", ID_ONE);
Ref b = NewRef("refs/heads/B", ID_TWO);
packed = ToList(a, b);
StringBuilder exp = new StringBuilder();
exp.Append("[");
exp.Append(a.ToString());
exp.Append(", ");
exp.Append(b.ToString());
exp.Append("]");
RefMap map = new RefMap(string.Empty, packed, loose, resolved);
NUnit.Framework.Assert.AreEqual(exp.ToString(), map.ToString());
}
protected void setUp()
{
packed = RefList<global::GitSharp.Core.Ref>.emptyList();
loose = RefList<global::GitSharp.Core.Ref>.emptyList();
resolved = RefList<global::GitSharp.Core.Ref>.emptyList();
}
public void testRemove()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
global::GitSharp.Core.Ref headU = newRef("HEAD", "refs/heads/master");
global::GitSharp.Core.Ref headR = newRef("HEAD", master);
packed = toList(master);
loose = toList(headU, master);
resolved = toList(headR);
RefMap map = new RefMap("", packed, loose, resolved);
Assert.IsNull(map.remove("not.a.reference"));
Assert.AreSame(master, map.remove("refs/heads/master"));
Assert.IsNull(map.get("refs/heads/master"));
Assert.AreSame(headR, map.remove("HEAD"));
Assert.IsNull(map.get("HEAD"));
Assert.IsTrue(map.isEmpty());
}
public void testPut_CollapseResolved()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
global::GitSharp.Core.Ref headU = newRef("HEAD", "refs/heads/master");
global::GitSharp.Core.Ref headR = newRef("HEAD", master);
global::GitSharp.Core.Ref a = newRef("refs/heads/A", ID_ONE);
loose = toList(headU, master);
resolved = toList(headR);
RefMap map = new RefMap("", packed, loose, resolved);
Assert.IsNull(map.put(a.getName(), a));
Assert.AreSame(a, map.get(a.getName()));
Assert.AreSame(headR, map.get("HEAD"));
}
public void testEntryType()
{
global::GitSharp.Core.Ref a = newRef("refs/heads/A", ID_ONE);
global::GitSharp.Core.Ref b = newRef("refs/heads/B", ID_TWO);
packed = toList(a, b);
RefMap map = new RefMap("refs/heads/", packed, loose, resolved);
IteratorBase<RefMap.Ent> itr = map.entrySet().iterator();
RefMap.Ent ent_a = itr.next();
RefMap.Ent ent_b = itr.next();
Assert.AreEqual(ent_a.GetHashCode(), "A".GetHashCode());
Assert.IsTrue(ent_a.Equals(ent_a));
Assert.IsFalse(ent_a.Equals(ent_b));
Assert.AreEqual(a.ToString(), ent_a.ToString());
}
public void testEntryTypeSet()
{
global::GitSharp.Core.Ref refA_one = newRef("refs/heads/A", ID_ONE);
global::GitSharp.Core.Ref refA_two = newRef("refs/heads/A", ID_TWO);
packed = toList(refA_one);
RefMap map = new RefMap("refs/heads/", packed, loose, resolved);
Assert.AreSame(refA_one, map.get("A"));
RefMap.Ent ent = map.entrySet().iterator().next();
Assert.AreEqual("A", ent.getKey());
Assert.AreSame(refA_one, ent.getValue());
Assert.AreSame(refA_one, ent.setValue(refA_two));
Assert.AreSame(refA_two, ent.getValue());
Assert.AreSame(refA_two, map.get("A"));
Assert.AreEqual(1, map.size());
}
public virtual void TestEntryType()
{
Ref a = NewRef("refs/heads/A", ID_ONE);
Ref b = NewRef("refs/heads/B", ID_TWO);
packed = ToList(a, b);
RefMap map = new RefMap("refs/heads/", packed, loose, resolved);
Iterator<KeyValuePair<string, Ref>> itr = map.EntrySet().Iterator();
KeyValuePair<string, Ref> ent_a = itr.Next();
KeyValuePair<string, Ref> ent_b = itr.Next();
// NUnit.Framework.Assert.AreEqual(ent_a.GetHashCode(), "A".GetHashCode());
NUnit.Framework.Assert.IsTrue(ent_a.Equals(ent_a));
NUnit.Framework.Assert.IsFalse(ent_a.Equals(ent_b));
NUnit.Framework.Assert.AreEqual(a.ToString(), ent_a.ToString());
}
public void testIterator_RefusesRemove()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
loose = toList(master);
RefMap map = new RefMap("", packed, loose, resolved);
IteratorBase<global::GitSharp.Core.Ref> itr = map.values().iterator();
Assert.IsTrue(itr.hasNext());
Assert.AreSame(master, itr.next());
try
{
itr.remove();
Assert.Fail("iterator allowed remove");
}
catch (NotSupportedException err)
{
// expected
}
}
public virtual void TestEntryTypeSet()
{
Ref refA_one = NewRef("refs/heads/A", ID_ONE);
Ref refA_two = NewRef("refs/heads/A", ID_TWO);
packed = ToList(refA_one);
RefMap map = new RefMap("refs/heads/", packed, loose, resolved);
NUnit.Framework.Assert.AreSame(refA_one, map.Get("A"));
KeyValuePair<string, Ref> ent = map.EntrySet().Iterator().Next();
NUnit.Framework.Assert.AreEqual("A", ent.Key);
NUnit.Framework.Assert.AreSame(refA_one, ent.Value);
// NUnit.Framework.Assert.AreSame(refA_one, ent.SetValue(refA_two));
// NUnit.Framework.Assert.AreSame(refA_two, ent.Value);
NUnit.Framework.Assert.AreSame(refA_two, map.Get("A"));
NUnit.Framework.Assert.AreEqual(1, map.Count);
}
public void testMerge_PackedLooseLoose()
{
global::GitSharp.Core.Ref refA = newRef("A", ID_ONE);
global::GitSharp.Core.Ref refB_ONE = newRef("B", ID_ONE);
global::GitSharp.Core.Ref refB_TWO = newRef("B", ID_TWO);
global::GitSharp.Core.Ref refc = newRef("c", ID_ONE);
packed = toList(refA, refB_ONE);
loose = toList(refB_TWO, refc);
RefMap map = new RefMap("", packed, loose, resolved);
Assert.AreEqual(3, map.size());
Assert.IsFalse(map.isEmpty());
Assert.IsTrue(map.containsKey(refA.Name));
Assert.AreSame(refA, map.get(refA.Name));
// loose overrides packed given same name
Assert.AreSame(refB_TWO, map.get(refB_ONE.Name));
var itr = map.values().iterator();
Assert.IsTrue(itr.hasNext());
Assert.AreSame(refA, itr.next());
Assert.IsTrue(itr.hasNext());
Assert.AreSame(refB_TWO, itr.next());
Assert.IsTrue(itr.hasNext());
Assert.AreSame(refc, itr.next());
Assert.IsFalse(itr.hasNext());
}
public virtual void SetUp()
{
packed = RefList.EmptyList();
loose = RefList.EmptyList();
resolved = RefList.EmptyList();
}
public void testNotEmpty_WithPrefix()
{
global::GitSharp.Core.Ref master = newRef("refs/heads/master", ID_ONE);
packed = toList(master);
RefMap map = new RefMap("refs/heads/", packed, loose, resolved);
Assert.IsFalse(map.isEmpty()); // before size was computed
Assert.AreEqual(1, map.size());
Assert.IsFalse(map.isEmpty()); // after size was computed
Assert.AreSame(master, map.values().iterator().next());
}
public virtual void TestIterator_MissingUnresolvedSymbolicRefIsBug()
{
Ref master = NewRef("refs/heads/master", ID_ONE);
Ref headR = NewRef("HEAD", master);
loose = ToList(master);
// loose should have added newRef("HEAD", "refs/heads/master")
resolved = ToList(headR);
RefMap map = new RefMap(string.Empty, packed, loose, resolved);
Iterator<Ref> itr = map.Values.Iterator();
try
{
itr.HasNext();
NUnit.Framework.Assert.Fail("iterator did not catch bad input");
}
catch (InvalidOperationException)
{
}
}
public void testPut_WithPrefix()
{
global::GitSharp.Core.Ref refA_one = newRef("refs/heads/A", ID_ONE);
global::GitSharp.Core.Ref refA_two = newRef("refs/heads/A", ID_TWO);
packed = toList(refA_one);
RefMap map = new RefMap("refs/heads/", packed, loose, resolved);
Assert.AreSame(refA_one, map.get("A"));
Assert.AreSame(refA_one, map.put("A", refA_two));
// map changed, but packed, loose did not
Assert.AreSame(refA_two, map.get("A"));
Assert.AreSame(refA_one, packed.get(0));
Assert.AreEqual(0, loose.size());
Assert.AreSame(refA_two, map.put("A", refA_one));
Assert.AreSame(refA_one, map.get("A"));
}
public virtual void TestMerge_WithPrefix()
{
Ref a = NewRef("refs/heads/A", ID_ONE);
Ref b = NewRef("refs/heads/foo/bar/B", ID_TWO);
Ref c = NewRef("refs/heads/foo/rab/C", ID_TWO);
Ref g = NewRef("refs/heads/g", ID_ONE);
packed = ToList(a, b, c, g);
RefMap map = new RefMap("refs/heads/foo/", packed, loose, resolved);
NUnit.Framework.Assert.AreEqual(2, map.Count);
NUnit.Framework.Assert.AreSame(b, map.Get("bar/B"));
NUnit.Framework.Assert.AreSame(c, map.Get("rab/C"));
NUnit.Framework.Assert.IsNull(map.Get("refs/heads/foo/bar/B"));
NUnit.Framework.Assert.IsNull(map.Get("refs/heads/A"));
NUnit.Framework.Assert.IsTrue(map.ContainsKey("bar/B"));
NUnit.Framework.Assert.IsTrue(map.ContainsKey("rab/C"));
NUnit.Framework.Assert.IsFalse(map.ContainsKey("refs/heads/foo/bar/B"));
NUnit.Framework.Assert.IsFalse(map.ContainsKey("refs/heads/A"));
Iterator<KeyValuePair<string, Ref>> itr = map.EntrySet().Iterator();
KeyValuePair<string, Ref> ent;
NUnit.Framework.Assert.IsTrue(itr.HasNext());
ent = itr.Next();
NUnit.Framework.Assert.AreEqual("bar/B", ent.Key);
NUnit.Framework.Assert.AreSame(b, ent.Value);
NUnit.Framework.Assert.IsTrue(itr.HasNext());
ent = itr.Next();
NUnit.Framework.Assert.AreEqual("rab/C", ent.Key);
NUnit.Framework.Assert.AreSame(c, ent.Value);
NUnit.Framework.Assert.IsFalse(itr.HasNext());
}
public void testToString_WithPrefix()
{
global::GitSharp.Core.Ref a = newRef("refs/heads/A", ID_ONE);
global::GitSharp.Core.Ref b = newRef("refs/heads/foo/B", ID_TWO);
global::GitSharp.Core.Ref c = newRef("refs/heads/foo/C", ID_TWO);
global::GitSharp.Core.Ref g = newRef("refs/heads/g", ID_ONE);
packed = toList(a, b, c, g);
StringBuilder exp = new StringBuilder();
exp.Append("[");
exp.Append(b.ToString());
exp.Append(", ");
exp.Append(c.ToString());
exp.Append("]");
RefMap map = new RefMap("refs/heads/foo/", packed, loose, resolved);
Assert.AreEqual(exp.ToString(), map.ToString());
}
public virtual void TestPut_WithPrefix()
{
Ref refA_one = NewRef("refs/heads/A", ID_ONE);
Ref refA_two = NewRef("refs/heads/A", ID_TWO);
packed = ToList(refA_one);
RefMap map = new RefMap("refs/heads/", packed, loose, resolved);
NUnit.Framework.Assert.AreSame(refA_one, map.Get("A"));
NUnit.Framework.Assert.AreSame(refA_one, map.Put("A", refA_two));
// map changed, but packed, loose did not
NUnit.Framework.Assert.AreSame(refA_two, map.Get("A"));
NUnit.Framework.Assert.AreSame(refA_one, packed.Get(0));
NUnit.Framework.Assert.AreEqual(0, loose.Size());
NUnit.Framework.Assert.AreSame(refA_two, map.Put("A", refA_one));
NUnit.Framework.Assert.AreSame(refA_one, map.Get("A"));
}
private RefList<global::GitSharp.Core.Ref> toList(params global::GitSharp.Core.Ref[] refs)
{
var b = new RefList<global::GitSharp.Core.Ref>.Builder<global::GitSharp.Core.Ref>(refs.Length);
b.addAll(refs, 0, refs.Length);
return b.toRefList();
}
public virtual void TestPut_CollapseResolved()
{
Ref master = NewRef("refs/heads/master", ID_ONE);
Ref headU = NewRef("HEAD", "refs/heads/master");
Ref headR = NewRef("HEAD", master);
Ref a = NewRef("refs/heads/A", ID_ONE);
loose = ToList(headU, master);
resolved = ToList(headR);
RefMap map = new RefMap(string.Empty, packed, loose, resolved);
NUnit.Framework.Assert.IsNull(map.Put(a.GetName(), a));
NUnit.Framework.Assert.AreSame(a, map.Get(a.GetName()));
NUnit.Framework.Assert.AreSame(headR, map.Get("HEAD"));
}
public virtual void TestMerge_PackedLooseLoose()
{
Ref refA = NewRef("A", ID_ONE);
Ref refB_ONE = NewRef("B", ID_ONE);
Ref refB_TWO = NewRef("B", ID_TWO);
Ref refc = NewRef("c", ID_ONE);
packed = ToList(refA, refB_ONE);
loose = ToList(refB_TWO, refc);
RefMap map = new RefMap(string.Empty, packed, loose, resolved);
NUnit.Framework.Assert.AreEqual(3, map.Count);
NUnit.Framework.Assert.IsFalse(map.IsEmpty());
NUnit.Framework.Assert.IsTrue(map.ContainsKey(refA.GetName()));
NUnit.Framework.Assert.AreSame(refA, map.Get(refA.GetName()));
// loose overrides packed given same name
NUnit.Framework.Assert.AreSame(refB_TWO, map.Get(refB_ONE.GetName()));
Iterator<Ref> itr = map.Values.Iterator();
NUnit.Framework.Assert.IsTrue(itr.HasNext());
NUnit.Framework.Assert.AreSame(refA, itr.Next());
NUnit.Framework.Assert.IsTrue(itr.HasNext());
NUnit.Framework.Assert.AreSame(refB_TWO, itr.Next());
NUnit.Framework.Assert.IsTrue(itr.HasNext());
NUnit.Framework.Assert.AreSame(refc, itr.Next());
NUnit.Framework.Assert.IsFalse(itr.HasNext());
}
public virtual void TestRemove()
{
Ref master = NewRef("refs/heads/master", ID_ONE);
Ref headU = NewRef("HEAD", "refs/heads/master");
Ref headR = NewRef("HEAD", master);
packed = ToList(master);
loose = ToList(headU, master);
resolved = ToList(headR);
RefMap map = new RefMap(string.Empty, packed, loose, resolved);
NUnit.Framework.Assert.IsNull(Sharpen.Collections.Remove(map, "not.a.reference"));
NUnit.Framework.Assert.AreSame(master, Sharpen.Collections.Remove(map, "refs/heads/master"
));
NUnit.Framework.Assert.IsNull(map.Get("refs/heads/master"));
NUnit.Framework.Assert.AreSame(headR, Sharpen.Collections.Remove(map, "HEAD"));
NUnit.Framework.Assert.IsNull(map.Get("HEAD"));
NUnit.Framework.Assert.IsTrue(map.IsEmpty());
}
