public void ShouldReturnFalseIfPropertyNotExists()
{
var dummyObject = new DummyObject();
var propertyReflection = new PropertyReflection();
var result = propertyReflection.HasProperty(dummyObject, "FooBar");
Assert.AreEqual(false, result);
}
public void ShouldReturnTrueIfPropertyExists()
{
var dummyObject = new DummyObject();
var propertyReflection = new PropertyReflection();
var result = propertyReflection.HasProperty(dummyObject, "DateTime");
Assert.AreEqual(true, result);
}
public void Empty_Strings_Are_Considered_Invalid()
{
var obj = new DummyObject();
var requiredField = new RequiredField<DummyObject>(obj, o => o.RequiredString);
Exception<BuilderException>
.ShouldBeThrownBy(requiredField.Validate);
}
public void Null_Values_Are_Considered_Invalid()
{
var obj = new DummyObject();
var requiredField = new RequiredField<DummyObject>(obj, o => o.ChildProperty);
Exception<BuilderException>
.ShouldBeThrownBy(requiredField.Validate);
}
public void ShouldGetPropertyValueSuccessfullyByRecursionOnParentObject()
{
var dummyObject = new DummyObject { Id = 5 };
var propertyReflection = new PropertyReflection();
var result = propertyReflection.GetPropertyValue(dummyObject, "Id", true);
Assert.IsNotNull(result);
Assert.AreEqual(5, Convert.ToInt32(result));
}
public void ShouldGetPropertyValueSuccessfully()
{
var dummyObject = new DummyObject { Name = "Stars" };
var propertyReflection = new PropertyReflection();
var result = propertyReflection.GetPropertyValue(dummyObject, "Name");
Assert.IsNotNull(result);
Assert.AreEqual(result, "Stars");
}
public void Should_be_able_to_inject()
{
var dummy = new DummyObject();
container.Setup(c => c.BuildUp(It.IsAny<object>()));
adapter.Inject(dummy);
container.VerifyAll();
}
public void Should_be_able_to_inject()
{
var dummy = new DummyObject();
container.Setup(c => c.BuildUp(It.IsAny<Type>(), It.IsAny<DummyObject>(), It.IsAny<string>(), It.IsAny<ResolverOverride[]>()));
adapter.Inject(dummy);
container.VerifyAll();
}
public void Non_Empty_Strings_Are_Considered_Valid()
{
var obj = new DummyObject
{
RequiredString = "Requirement Met"
};
var requiredField = new RequiredField<DummyObject>(obj, o => o.RequiredString);
requiredField.Validate(); // no exception expected
}
public void Non_Null_Values_Are_Considered_Valid()
{
var obj = new DummyObject
{
ChildProperty = new DummyObject()
};
var requiredField = new RequiredField<DummyObject>(obj, o => o.ChildProperty);
requiredField.Validate(); // no exception expected
}
public void ShouldThrowExceptionWhenPropertyNotExistingOnGettingValue()
{
var dummyObject = new DummyObject();
var propertyReflection = new PropertyReflection();
var result = Assert.Throws<Exception>(() =>
propertyReflection.GetPropertyValue(dummyObject, "Doughnut"));
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(Exception), result);
Assert.AreEqual("Property Doughnut does not exist on DummyObject object", result.Message);
}
public void Deserialize()
{
const string expectedSerialized = "{\"visible\":\"visible\"}";
var dummy = new DummyObject {invisible = "invisible", visible = "visible"};
var serializer = new JsonSerializer();
var serialized = serializer.Serialize(dummy);
Assert.AreEqual(expectedSerialized, serialized);
var result = serializer.Deserialize<DummyObject>(serialized);
Assert.AreEqual("visible", result.visible);
}
public void Awake()
{
for (int i = 0; i < LOCK_COUNT; i++)
{
lockTargets[i] = new DummyObject();
}
int lastVoxelIndex = -1;
for (int i = 0; i < WORKER_COUNT; i++)
{
workers[i] = new Worker(lastVoxelIndex + 1, lastVoxelIndex = (DFSLayoutMath.count() * (i + 1)) / WORKER_COUNT - 1);
workerThreads[i] = new Thread(workers[i].Run);
}
}
public void SetupTests()
{
_client = new DynamoDbCacheClient(yourAwsAccountKey, yourAwsSecretKey,
RegionEndpoint.USEast1, "ICacheClientDynamoDb", 10, 5, true);
// The primary item we'll be caching in the tests.
_item = new DummyObject
{
UserId = "john.doe",
Email = "*****@*****.**",
Phone = "555-555-9876",
Friends = new List<string> {"jane.doe", "jack.doe", "some.friend"}
};
}
public void IfNotNullTest()
{
// Nothing null.
DummyObject dummy = new DummyObject();
MainClass notNull = new MainClass
{
Inner = new InnerClass
{
Dummy = dummy
}
};
DummyObject inner = notNull.IfNotNull( x => x.Inner ).IfNotNull( x => x.Dummy );
Assert.AreEqual( dummy, inner );
// Halfway null.
MainClass halfwayNull = new MainClass
{
Inner = new InnerClass()
};
inner = halfwayNull.IfNotNull( x => x.Inner ).IfNotNull( x => x.Dummy );
Assert.IsNull( inner );
// All null.
MainClass isNull = null;
inner = isNull.IfNotNull( x => x.Inner ).IfNotNull( x => x.Dummy );
Assert.IsNull( inner );
// Value type.
const int setValue = 10;
MainClass value = new MainClass
{
Inner = new InnerClass
{
Dummy = new DummyObject
{
Value = setValue
}
}
};
int innerValue = value.IfNotNull( x => x.Inner ).IfNotNull( x => x.Dummy ).IfNotNull( x => x.Value );
Assert.AreEqual( setValue, innerValue );
}
public void ReferenceOrBoxedValueEqualsTest()
{
// ints
object one = 1;
object alsoOne = 1;
object notOne = 2;
Assert.AreEqual( true, one.ReferenceOrBoxedValueEquals( alsoOne ) );
Assert.AreEqual( false, one.ReferenceOrBoxedValueEquals( notOne ) );
// strings
object bleh = "bleh";
object equalBleh = "bleh";
object notBleh = "notbleh";
Assert.AreEqual( true, bleh.ReferenceOrBoxedValueEquals( equalBleh ) );
Assert.AreEqual( false, bleh.ReferenceOrBoxedValueEquals( notBleh ) );
// Reference types.
object dummy1 = new DummyObject();
object dummy2 = new DummyObject();
Assert.AreEqual( true, dummy1.ReferenceOrBoxedValueEquals( dummy1 ) );
Assert.AreEqual( false, dummy1.ReferenceOrBoxedValueEquals( dummy2 ) );
}
public void Assert_ActionTReturn_ActionException()
{
Action TestCase(int testNumber, TestActual <DummyObject> testActual, AssertReturn @return, AssertException assertException, (DummyObject @return, Exception assertException) expected, Type expectedExceptionType = null) => () => {
var msg = "No." + testNumber;
// Act
Exception exception_ = null;
try {
testActual.Assert(@return?.Invoke, assertException?.Invoke);
}
catch (Exception ex_) {
exception_ = ex_;
}
// Assert
Assert.AreEqual(expectedExceptionType, exception_?.GetType(), msg);
Assert.AreEqual(expected.@return, @return?.InvokedParams, msg);
Assert.AreEqual(expected.assertException, assertException?.InvokedParams, msg);
};
var obj = new DummyObject();
var ex = new DummyException();
foreach (var action in new[] {
/// <summary>
/// Initializes a new instance of the <see cref="DummyObjectDealer"/> class.
/// </summary>
public DummyObjectDealer(Int32 dummyNumber, DummyObject dummyObject)
{
DummyObject = dummyObject;
DummyObject.DummyNumber = dummyNumber;
}
protected override void ExecuteImpl()
{
base.ExecuteImpl();
var testPack = SelectedObject.Id;
var test = SelectedObject;
stopwatch = Stopwatch.StartNew();
int packSize = 100;
test.PackSize = packSize;
Log(string.Format("Creating test objects. Size: {0}", packSize));
var pack1B =
Enumerable.Range(1, packSize)
.Select((i) => DummyObject.Create1B(testPack))
.ToList();
var pack1K =
Enumerable.Range(1, packSize)
.Select((i) => DummyObject.Create1K(testPack))
.ToList();
var pack10K =
Enumerable.Range(1, packSize)
.Select((i) => DummyObject.Create10K(testPack))
.ToList();
var pack100K =
Enumerable.Range(1, packSize)
.Select((i) => DummyObject.Create100K(testPack))
.ToList();
var pack1000K =
Enumerable.Range(1, packSize)
.Select((i) => DummyObject.Create1000K(testPack))
.ToList();
LogTime("Objects ready.");
using (var db = new FrameworkDbContext())
{
test.AverageTime1B = RunTest("1B", pack1B, db);
test.AverageTime1K = RunTest("1K", pack1K, db);
test.AverageTime10K = RunTest("10K", pack10K, db);
test.AverageTime100K = RunTest("100K", pack100K, db);
test.AverageTime1000K = RunTest("1000K", pack1000K, db);
var queryAll =
db.Set <DummyObject>()
.Where(d => d.TestPack == testPack);
LogLine("");
LogTime("Loading All started.");
var list = queryAll.ToList();
long loadTime = stopwatch.ElapsedMilliseconds;
LogLine(string.Format("\tLoad Time:\t{0} ms", loadTime));
test.LoadAllTime = loadTime;
LogLine(string.Format("\tCount:\t{0}", list.Count));
test.LoadAllCount = list.Count;
}
}
public void Should_be_able_to_inject()
{
var dummy = new DummyObject();
kernel.Setup(c => c.Inject(It.IsAny<object>()));
adapter.Inject(dummy);
kernel.VerifyAll();
}
public void ReplaceTokensWithObjectValuesTest()
{
DummyObject dummy = new DummyObject("But listen to the color of your dreams", 7, 1000);
const string textWithTokens = "Revolver was the Beatles [DummyObject.IntProperty]th album. John wanted the song Tomorrow Never Knows to sound like [DummyObject.DecimalProperty] monks chanting to lyrics like '[DummyObject.StringProperty]'.";
const string textWithoutTokens = "Revolver was the Beatles 7th album. John wanted the song Tomorrow Never Knows to sound like 1000 monks chanting to lyrics like 'But listen to the color of your dreams'.";
string processed = _stringUtility.ReplaceTokensWithObjectValues(textWithTokens, dummy);
Assert.That(processed == textWithoutTokens);
}
protected bool Equals(DummyObject other)
{
return(string.Equals(_val, other._val));
}
public void ShouldSetPropertySuccessfully()
{
var dummyObject = new DummyObject();
var propertyReflection = new PropertyReflection();
Assert.DoesNotThrow(() => propertyReflection.SetProperty(dummyObject, "Name", "FooBar"));
Assert.AreEqual(dummyObject.Name, "FooBar");
}
/// <summary>
/// Creates a new DummyObject with values copied from another.
/// </summary>
public DummyObject(DummyObject clone) : base(clone)
{
}
private void OnEnable()
{
dummyObject = CreateInstance <DummyObject>();
}
/// <summary>
/// Initializes a new instance of the <see cref="DummyObjectDealer"/> class.
/// </summary>
public DummyObjectDealer(Int32 dummyNumber, DummyObject dummyObject)
{
DummyObject = dummyObject;
DummyObject.DummyNumber = dummyNumber;
}
private void ReplayAndRaycast()
{
playerDummy1 = Instantiate(dummyPlayerPrefab).GetComponent <DummyObject>();
playerDummy1.originalOwner = playerID1;
playerDummy2 = Instantiate(dummyPlayerPrefab).GetComponent <DummyObject>();
playerDummy2.originalOwner = playerID2;
playerDummy3 = Instantiate(dummyPlayerPrefab).GetComponent <DummyObject>();
playerDummy3.originalOwner = playerID3;
panelDummy1 = Instantiate(dummyPanelPrefab).GetComponent <DummyObject>();
panelDummy1.originalOwner = playerID1;
panelDummy2 = Instantiate(dummyPanelPrefab).GetComponent <DummyObject>();
panelDummy2.originalOwner = playerID2;
panelDummy3 = Instantiate(dummyPanelPrefab).GetComponent <DummyObject>();
panelDummy3.originalOwner = playerID3;
visualisationDummies = new List <DummyObject>();
StreamWriter streamWriter1 = new StreamWriter(string.Format("C:\\Users\\blee33\\Desktop\\q{1}_p{0}_raycast.txt", playerID1, question), true);
StreamWriter streamWriter2 = new StreamWriter(string.Format("C:\\Users\\blee33\\Desktop\\q{1}_p{0}_raycast.txt", playerID2, question), true);
StreamWriter streamWriter3 = new StreamWriter(string.Format("C:\\Users\\blee33\\Desktop\\q{1}_p{0}_raycast.txt", playerID3, question), true);
streamWriter1.WriteLine("Timestamp\tGazeObject\tGazeObjectOwner\tLeftPointObject\tLeftPointObjectOwner\tRightPointObject\tRightPointObjectOwner");
streamWriter2.WriteLine("Timestamp\tGazeObject\tGazeObjectOwner\tLeftPointObject\tLeftPointObjectOwner\tRightPointObject\tRightPointObjectOwner");
streamWriter3.WriteLine("Timestamp\tGazeObject\tGazeObjectOwner\tLeftPointObject\tLeftPointObjectOwner\tRightPointObject\tRightPointObjectOwner");
string[] objectDataLines = objectData.text.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
string[] playerDataLines1 = playerData1.text.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
string[] playerDataLines2 = playerData2.text.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
string[] playerDataLines3 = playerData3.text.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
int j = 1;
for (int i = 1; i < playerDataLines1.Length; i++)
{
float currentTime = float.Parse(playerDataLines1[i].Split('\t')[0]);
int visualisationIndex = 0;
int panelIndex = 0;
// Position objects at this timestamp
while (j < objectDataLines.Length)
{
string[] values = objectDataLines[j].Split('\t');
if (IsEqual(float.Parse(values[0]), currentTime))
{
switch (values[1])
{
case "Panel":
DummyObject panel = null;
if (int.Parse(values[2]) == playerID1)
{
panel = panelDummy1;
}
else if (int.Parse(values[2]) == playerID2)
{
panel = panelDummy2;
}
else if (int.Parse(values[2]) == playerID3)
{
panel = panelDummy3;
}
panel.transform.position = new Vector3(float.Parse(values[3]), float.Parse(values[4]), float.Parse(values[5]));
panel.transform.rotation = new Quaternion(float.Parse(values[6]), float.Parse(values[7]), float.Parse(values[8]), float.Parse(values[9]));
break;
case "Visualisation":
DummyObject vis;
if (visualisationIndex < visualisationDummies.Count)
{
vis = visualisationDummies[visualisationIndex];
}
else
{
vis = Instantiate(dummyVisualisationPrefab).GetComponent <DummyObject>();
visualisationDummies.Add(vis);
}
visualisationIndex++;
vis.originalOwner = int.Parse(values[2]);
vis.transform.position = new Vector3(float.Parse(values[3]), float.Parse(values[4]), float.Parse(values[5]));
vis.transform.rotation = new Quaternion(float.Parse(values[6]), float.Parse(values[7]), float.Parse(values[8]), float.Parse(values[9]));
vis.transform.localScale = new Vector3(float.Parse(values[10]), float.Parse(values[11]), 0.1f);
break;
}
j++;
}
else
{
break;
}
}
// Remove unncessary visualisations
for (int k = visualisationDummies.Count - 1; k > visualisationIndex; k--)
{
DummyObject d = visualisationDummies[k];
visualisationDummies.Remove(d);
DestroyImmediate(d.gameObject);
}
// Position players at this timestamp
// Player 1
string[] playerValues1 = playerDataLines1[i].Split('\t');
playerDummy1.transform.position = new Vector3(float.Parse(playerValues1[1]), float.Parse(playerValues1[2]), float.Parse(playerValues1[3]));
playerDummy1.transform.rotation = new Quaternion(float.Parse(playerValues1[4]), float.Parse(playerValues1[5]), float.Parse(playerValues1[6]), float.Parse(playerValues1[7]));
// Player 2
string[] playerValues2 = playerDataLines2[i].Split('\t');
playerDummy2.transform.position = new Vector3(float.Parse(playerValues2[1]), float.Parse(playerValues2[2]), float.Parse(playerValues2[3]));
playerDummy2.transform.rotation = new Quaternion(float.Parse(playerValues2[4]), float.Parse(playerValues2[5]), float.Parse(playerValues2[6]), float.Parse(playerValues2[7]));
// Player 3
string[] playerValues3 = playerDataLines3[i].Split('\t');
playerDummy3.transform.position = new Vector3(float.Parse(playerValues3[1]), float.Parse(playerValues3[2]), float.Parse(playerValues3[3]));
playerDummy3.transform.rotation = new Quaternion(float.Parse(playerValues3[4]), float.Parse(playerValues3[5]), float.Parse(playerValues3[6]), float.Parse(playerValues3[7]));
// Perform raycasts
// Gaze
RaycastedObject p1 = DoRaycast(playerDummy1.transform.position, playerDummy1.transform.forward, playerID1, true);
RaycastedObject p2 = DoRaycast(playerDummy2.transform.position, playerDummy2.transform.forward, playerID2, true);
RaycastedObject p3 = DoRaycast(playerDummy3.transform.position, playerDummy3.transform.forward, playerID3, true);
// Left point
RaycastedObject lp1 = DoRaycast(new Vector3(float.Parse(playerValues1[8]), float.Parse(playerValues1[9]), float.Parse(playerValues1[10])),
new Quaternion(float.Parse(playerValues1[11]), float.Parse(playerValues1[12]), float.Parse(playerValues1[13]), float.Parse(playerValues1[14])) * Vector3.forward,
playerID1
);
RaycastedObject lp2 = DoRaycast(new Vector3(float.Parse(playerValues2[8]), float.Parse(playerValues2[9]), float.Parse(playerValues2[10])),
new Quaternion(float.Parse(playerValues2[11]), float.Parse(playerValues2[12]), float.Parse(playerValues2[13]), float.Parse(playerValues2[14])) * Vector3.forward,
playerID2
);
RaycastedObject lp3 = DoRaycast(new Vector3(float.Parse(playerValues3[8]), float.Parse(playerValues3[9]), float.Parse(playerValues3[10])),
new Quaternion(float.Parse(playerValues3[11]), float.Parse(playerValues3[12]), float.Parse(playerValues3[13]), float.Parse(playerValues3[14])) * Vector3.forward,
playerID3
);
// Right point
RaycastedObject rp1 = DoRaycast(new Vector3(float.Parse(playerValues1[19]), float.Parse(playerValues1[20]), float.Parse(playerValues1[21])),
new Quaternion(float.Parse(playerValues1[22]), float.Parse(playerValues1[23]), float.Parse(playerValues1[24]), float.Parse(playerValues1[25])) * Vector3.forward,
playerID1
);
RaycastedObject rp2 = DoRaycast(new Vector3(float.Parse(playerValues2[19]), float.Parse(playerValues2[20]), float.Parse(playerValues2[21])),
new Quaternion(float.Parse(playerValues2[22]), float.Parse(playerValues2[23]), float.Parse(playerValues2[24]), float.Parse(playerValues2[25])) * Vector3.forward,
playerID2
);
RaycastedObject rp3 = DoRaycast(new Vector3(float.Parse(playerValues3[19]), float.Parse(playerValues3[20]), float.Parse(playerValues3[21])),
new Quaternion(float.Parse(playerValues3[22]), float.Parse(playerValues3[23]), float.Parse(playerValues3[24]), float.Parse(playerValues3[25])) * Vector3.forward,
playerID3
);
// Write to file
streamWriter1.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}", playerValues1[0], p1.type, p1.originalOwner, lp1.type, lp1.originalOwner, rp1.type, rp1.originalOwner);
streamWriter2.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}", playerValues2[0], p2.type, p2.originalOwner, lp2.type, lp2.originalOwner, rp2.type, rp2.originalOwner);
streamWriter3.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}", playerValues3[0], p3.type, p3.originalOwner, lp3.type, lp3.originalOwner, rp3.type, rp3.originalOwner);
}
streamWriter1.Close();
streamWriter2.Close();
streamWriter3.Close();
}
public void MapObjectTest()
{
DummyObject dummyOne = new DummyObject();
DummyObjectTwo dummyTwo = new DummyObjectTwo();
_objectUtility.MapObject(_dummyObject, dummyOne);
_objectUtility.MapObject(_dummyObject, dummyTwo);
DummyObject nestedNew = (DummyObject)dummyOne.ObjectProperty;
DummyObject nestedOriginal = (DummyObject) _dummyObject.ObjectProperty;
Assert.That(dummyOne.StringProperty == _dummyObject.StringProperty);
Assert.That(dummyOne.IntProperty == _dummyObject.IntProperty);
Assert.That(dummyOne.DecimalProperty == _dummyObject.DecimalProperty);
Assert.That(nestedNew.StringProperty == nestedOriginal.StringProperty);
Assert.That(dummyTwo.StringProperty == _dummyObject.StringProperty);
dummyOne.StringProperty = "New String Property";
Assert.That(dummyOne.StringProperty != _dummyObject.StringProperty);
}
