public void TestIsAsSafeOrSaferThan()
{
var safeConf = UnsafeSandboxConfigurationExtensions.SafeDefaults;
var unsafeConf = new UnsafeSandboxConfiguration()
{
MonitorFileAccesses = !safeConf.MonitorFileAccesses
};
var moreUnsafeConf = new UnsafeSandboxConfiguration()
{
MonitorFileAccesses = !safeConf.MonitorFileAccesses, SandboxKind = SandboxKind.None
};
// assert reflexivity
XAssert.IsTrue(safeConf.IsAsSafeOrSaferThan(safeConf));
XAssert.IsTrue(unsafeConf.IsAsSafeOrSaferThan(unsafeConf));
XAssert.IsTrue(moreUnsafeConf.IsAsSafeOrSaferThan(moreUnsafeConf));
// assert order
XAssert.IsTrue(safeConf.IsAsSafeOrSaferThan(unsafeConf));
XAssert.IsTrue(safeConf.IsAsSafeOrSaferThan(moreUnsafeConf));
XAssert.IsTrue(unsafeConf.IsAsSafeOrSaferThan(moreUnsafeConf));
// assert reverse order
XAssert.IsFalse(unsafeConf.IsAsSafeOrSaferThan(safeConf));
XAssert.IsFalse(moreUnsafeConf.IsAsSafeOrSaferThan(safeConf));
XAssert.IsFalse(moreUnsafeConf.IsAsSafeOrSaferThan(unsafeConf));
}
private static byte[] SerializeToByteArray(UnsafeSandboxConfiguration conf)
{
using (var stream = new MemoryStream())
using (var writer = new BuildXLWriter(debug: true, stream: stream, leaveOpen: true, logStats: true))
{
conf.Serialize(writer);
return(stream.GetBuffer());
}
}
public void TestIsAsSafeOrSaferDynamicWriteOnAbsentProbePolicy(DynamicWriteOnAbsentProbePolicy lhs, DynamicWriteOnAbsentProbePolicy rhs, bool expectedOutcome)
{
XAssert.AreEqual(expectedOutcome, UnsafeSandboxConfigurationExtensions.IsAsSafeOrSafer(lhs, rhs));
var lhsConf = new UnsafeSandboxConfiguration {
IgnoreDynamicWritesOnAbsentProbes = lhs
};
var rhsConf = new UnsafeSandboxConfiguration {
IgnoreDynamicWritesOnAbsentProbes = rhs
};
XAssert.AreEqual(expectedOutcome, lhsConf.IsAsSafeOrSaferThan(rhsConf));
}
public void TestIsAsSafeOrSaferThanPreloaded()
{
var safeConf = new UnsafeSandboxConfiguration()
{
IgnorePreloadedDlls = false
};
var unsafeConf = new UnsafeSandboxConfiguration()
{
IgnorePreloadedDlls = true
};
XAssert.IsTrue(safeConf.IsAsSafeOrSaferThan(unsafeConf));
XAssert.IsFalse(unsafeConf.IsAsSafeOrSaferThan(safeConf));
}
public void TestSerializationIncludesProperty(PropertyInfo propertyInfo, object value1, object value2)
{
var conf = new UnsafeSandboxConfiguration();
propertyInfo.SetValue(conf, value1);
var serializedBytes1 = SerializeToByteArray(conf);
XAssert.AreEqual(value1, propertyInfo.GetValue(DeserializeFromByteArray(serializedBytes1)));
propertyInfo.SetValue(conf, value2);
var serializedBytes2 = SerializeToByteArray(conf);
XAssert.AreEqual(value2, propertyInfo.GetValue(DeserializeFromByteArray(serializedBytes2)));
// checking that serialized byte arrays are not equal ensures that the property was accounted for during serialization
XAssert.ArrayNotEqual(serializedBytes1, serializedBytes2);
}
public void TestIsAsSafeOrSaferThanByProperty(PropertyInfo propertyInfo, object value1, object value2)
{
Func <object> failFn = () =>
{
XAssert.Fail($"Expected at lease one of the 2 values returned for property '{propertyInfo.Name}' to be different from the value in 'SafeDefaults'");
return(null);
};
var safeConf = UnsafeSandboxConfigurationExtensions.SafeDefaults;
var safePropertyValue = propertyInfo.GetValue(safeConf);
var unsafePropertyValue =
!EqualityComparer <object> .Default.Equals(value1, safePropertyValue) ? value1 :
!EqualityComparer <object> .Default.Equals(value2, safePropertyValue) ? value2 :
failFn();
var unsafeConf = new UnsafeSandboxConfiguration();
propertyInfo.SetValue(unsafeConf, unsafePropertyValue);
var msg = $"prop: '{propertyInfo.Name}'; safe value: '{safePropertyValue}'; unsafe property value: '{unsafePropertyValue}'";
XAssert.IsTrue(safeConf.IsAsSafeOrSaferThan(unsafeConf), msg);
XAssert.IsFalse(unsafeConf.IsAsSafeOrSaferThan(safeConf), msg);
}
