public void AddMissingExceptions()
{
using (var stream = typeof(ExtractorTest).GetEmbedded("testArchive.zip"))
using (var microServer = new MicroServer("archive.zip", stream))
{
var implementation = new Implementation {ManifestDigest = new ManifestDigest(sha1New: "invalid"), RetrievalMethods = {new Archive {Href = microServer.FileUri}}};
Assert.Throws<DigestMismatchException>(() => implementation.AddMissing(new SilentTaskHandler()));
}
}
public void AddMissingArchive()
{
using (var stream = typeof(ExtractorTest).GetEmbedded("testArchive.zip"))
using (var microServer = new MicroServer("archive.zip", stream))
{
var implementation = new Implementation {RetrievalMethods = {new Archive {Href = microServer.FileUri}}};
implementation.AddMissing(new SilentTaskHandler());
Assert.AreEqual(ArchiveSha256Digest, implementation.ManifestDigest.Sha256New);
var archive = (Archive)implementation.RetrievalMethods[0];
Assert.AreEqual(Archive.MimeTypeZip, archive.MimeType);
Assert.AreEqual(stream.Length, archive.Size);
}
}
public void SetFieldWithClassTest()
{
var container = new DummyContainer();
var newInstance = new Implementation();
container.SetField("_instance", newInstance);
Assert.AreEqual(newInstance, container.Instance);
}
/// <summary>
/// generate a mock object that looks like EventLog, and return it
/// </summary>
/// <returns>a mock of Eventlog</returns>
public static Implementation<EventLog> GetEventLogMock()
{
Implementation<EventLog> mock = new Implementation<EventLog>();
mock.Register("get_Source")
.Execute(() =>
{
// we don't care about the Source property for testing purposes
return String.Empty;
});
mock.Register("set_Source")
.Execute((string theValue) =>
{
// we don't care about the Source property for testing purposes
});
mock.Register(instance => instance.WriteEvent(Argument<EventInstance>.Any, Argument<object[]>.Any))
.Execute((EventInstance eventInstance, object[] args) =>
{
mockLogEntries.Add(
new Tuple<int, EventLogEntryType, long, string>
(
eventInstance.CategoryId,
eventInstance.EntryType,
eventInstance.InstanceId,
args.Aggregate((a, b) => string.Format("{0}\r\n\r\n{1}", a, b)).ToString()
)
);
});
return mock;
}
public ChangeInterfaceOfClassifierCommand(
Implementation existingInterface,
ClassifierDictionary classifiers,
MessageSystem messageSystem)
{
_existingInterface = existingInterface;
_classifiers = classifiers;
_messageSystem = messageSystem;
}
public CallSite(Implementation impl, Block b, int stmt, ProcedureSummaryEntry summaryEntry) {
Contract.Requires(summaryEntry != null);
Contract.Requires(b != null);
Contract.Requires(impl != null);
this.Impl = impl;
this.Block = b;
this.Statement = stmt;
this.SummaryEntry = summaryEntry;
}
private Implementation GetFor(object obj)
{
lock (_cache)
{
var type = obj.GetType();
Implementation rv;
if (!_cache.TryGetValue(type, out rv))
_cache[type] = rv = new Implementation(type);
return rv;
}
}
/// <summary>
/// Creates a new owned implementation node.
/// </summary>
/// <param name="digest">The digest identifying the implementation.</param>
/// <param name="implementation">Information about the implementation from a <see cref="Feed"/> file.</param>
/// <param name="parent">The node of the feed owning the implementation.</param>
/// <param name="store">The <see cref="IStore"/> the implementation is located in.</param>
/// <exception cref="FormatException">The manifest file is not valid.</exception>
/// <exception cref="IOException">The manifest file could not be read.</exception>
/// <exception cref="UnauthorizedAccessException">Read access to the file is not permitted.</exception>
public OwnedImplementationNode(ManifestDigest digest, [NotNull] Implementation implementation, [NotNull] FeedNode parent, [NotNull] IStore store)
: base(digest, store)
{
#region Sanity checks
if (implementation == null) throw new ArgumentNullException("implementation");
if (parent == null) throw new ArgumentNullException("parent");
if (store == null) throw new ArgumentNullException("store");
#endregion
_parent = parent;
_implementation = implementation;
}
public Player(IMap map, String name, String Civ, Implementation.PlayerColor col)
{
if (Civ == "INFO")
Civilization = CivilizationType.INFO;
else
Civilization = CivilizationType.EII;
Teachers = new List<ITeacher>();
Students = new List<IStudent>();
Name = name;
Cities = new List<ICity>();
Status = StatusType.InGame;
Color = col;
}
/// <summary>
/// Hooks into the creation of new processes on the current thread to inject API hooks.
/// </summary>
/// <param name="selections">The implementations chosen for launch.</param>
/// <param name="executor">The executor used to launch the new process.</param>
/// <param name="feedManager">Provides access to remote and local <see cref="Feed"/>s. Handles downloading, signature verification and caching.</param>
/// <param name="handler">A callback object used when the the user needs to be asked questions or informed about download and IO tasks.</param>
/// <exception cref="ImplementationNotFoundException">The main implementation is not cached (possibly because it is installed natively).</exception>
public RunHook(Selections selections, IExecutor executor, IFeedManager feedManager, ITaskHandler handler)
{
var feed = feedManager[selections.InterfaceUri];
_target = new FeedTarget(selections.InterfaceUri, feed);
var mainImplementation = selections.MainImplementation;
_implementationDir = executor.GetImplementationPath(mainImplementation);
_mainImplementation = feed[mainImplementation.ID];
_handler = handler;
_registryFilter = GetRegistryFilter();
_relaunchControl = GetRelaunchControl();
Log.Info("Activating API hooking");
_hookW = LocalHook.Create(LocalHook.GetProcAddress("kernel32.dll", "CreateProcessW"), new UnsafeNativeMethods.DCreateProcessW(CreateProcessWCallback), null);
_hookW.ThreadACL.SetInclusiveACL(new[] {Thread.CurrentThread.ManagedThreadId});
_hookA = LocalHook.Create(LocalHook.GetProcAddress("kernel32.dll", "CreateProcessA"), new UnsafeNativeMethods.DCreateProcessA(CreateProcessACallback), null);
_hookA.ThreadACL.SetInclusiveACL(new[] {Thread.CurrentThread.ManagedThreadId});
}
public void TestGetImplementation()
{
var digest1 = new ManifestDigest(sha256: "123");
var implementation1 = new Implementation {ManifestDigest = digest1};
var feed1 = new Feed {Elements = {implementation1}};
var digest2 = new ManifestDigest(sha256: "abc");
var implementation2 = new Implementation {ManifestDigest = digest2};
var feed2 = new Feed {Elements = {implementation2}};
var feeds = new[] {feed1, feed2};
Feed feed;
Assert.AreEqual(implementation1, feeds.GetImplementation(digest1, out feed));
Assert.AreEqual(feed1, feed);
Assert.AreEqual(implementation2, feeds.GetImplementation(digest2, out feed));
Assert.AreEqual(feed2, feed);
Assert.IsNull(feeds.GetImplementation(new ManifestDigest(sha256: "invalid"), out feed), "No implementation should have been found");
Assert.IsNull(feed, "No feed should have been found");
}
public void TestGetImplementation()
{
var digest1 = new ManifestDigest(sha256: "123");
var implementation1 = new Implementation {ManifestDigest = digest1};
var feed1 = new Feed {Elements = {implementation1}};
var digest2 = new ManifestDigest(sha256: "abc");
var implementation2 = new Implementation {ManifestDigest = digest2};
var feed2 = new Feed {Elements = {implementation2}};
var feeds = new[] {feed1, feed2};
Feed feed;
feeds.GetImplementation(digest1, out feed).Should().Be(implementation1);
feed.Should().Be(feed1);
feeds.GetImplementation(digest2, out feed).Should().Be(implementation2);
feed.Should().Be(feed2);
feeds.GetImplementation(new ManifestDigest(sha256: "invalid"), out feed).Should().BeNull(because: "No implementation should have been found");
feed.Should().BeNull(because: "No feed should have been found");
}
public void TestNormalizeRejectLocalPath()
{
var implmementation = new Implementation {LocalPath = "subdir"};
implmementation.Normalize(FeedTest.Test1Uri);
Assert.IsNull(implmementation.LocalPath);
}
public async Task TestDrainFullyAsync()
{
Implementation implementation = new Implementation();
await implementation.TestDrainFullyAsync();
}
public async Task TestSplitAsync()
{
Implementation implementation = new Implementation();
await implementation.TestSplitAsync();
}
private void ProcessWrapperProcedure(Implementation impl)
{
this.InternalImplementation.Proc = impl.Proc;
}
private void ProcessRegionBlocks(Implementation impl)
{
this.RegionBlocks = impl.Blocks;
this.RegionHeader = this.CreateRegionHeader();
}
public async Task Test429sAsync()
{
Implementation implementation = new Implementation(false);
await implementation.Test429sAsync();
}
public void setImplementation(Implementation impl)
{
this.impl = impl;
}
public void Test()
{
Assert.Equal(23, Implementation.Solution(10));
}
public void ValueIsNegative()
{
Assert.Equal(0, Implementation.Solution(-15));
}
public void ValueIsZero()
{
Assert.Equal(0, Implementation.Solution(0));
}
public void Test200()
{
Assert.Equal(9168, Implementation.Solution(200));
}
public FollowSocialPersonaIntent()
{
Self = Implementation.Constructor();
}
public PollCapabilityInput()
{
Self = Implementation.Constructor();
}
public void AddMissingRecipe()
{
using (var stream = typeof(ArchiveExtractorTest).GetEmbeddedStream("testArchive.zip"))
using (var microServer = new MicroServer("archive.zip", stream))
{
var implementation = new Implementation {RetrievalMethods = {new Recipe {Steps = {new Archive {Href = microServer.FileUri}}}}};
implementation.AddMissing(new SilentTaskHandler());
implementation.ManifestDigest.Sha256New.Should().Be(ArchiveSha256Digest);
var archive = (Archive)((Recipe)implementation.RetrievalMethods[0]).Steps[0];
archive.MimeType.Should().Be(Archive.MimeTypeZip);
archive.Size.Should().Be(stream.Length);
}
}
public PetrolPumpWindow()
{
this.assemblyName = this.GetType().Assembly.FullName;
this.InitializeComponent();
Func<Image>[] largeSegments = new Func<Image>[8];
Func<Image>[] smallSegments = new Func<Image>[8];
for (int i = 0; i < 8; i++)
{
int n = i;
largeSegments[i] = () =>
{
Image image = new Image();
BitmapImage source = new BitmapImage();
source.BeginInit();
source.UriSource = new Uri("pack://application:,,,/" + this.assemblyName + ";component/images/large" + n + ".png");
source.EndInit();
image.Source = source;
image.Width = source.PixelWidth;
image.Height = source.PixelHeight;
return image;
};
smallSegments[i] = () =>
{
Image image = new Image();
BitmapImage source = new BitmapImage();
source.BeginInit();
source.UriSource = new Uri("pack://application:,,,/" + this.assemblyName + ";component/images/small" + n + ".png");
source.EndInit();
image.Source = source;
image.Width = source.PixelWidth;
image.Height = source.PixelHeight;
return image;
};
}
IReadOnlyList<IReadOnlyList<int>> layouts = new[]
{
new[] { 0, 1, 2, 4, 5, 6 },
new[] { 2, 5 },
new[] { 0, 1, 3, 5, 6 },
new[] { 0, 2, 3, 5, 6 },
new[] { 2, 3, 4, 5 },
new[] { 0, 2, 3, 4, 6 },
new[] { 0, 1, 2, 3, 4, 6 },
new[] { 2, 5, 6 },
new[] { 0, 1, 2, 3, 4, 5, 6 },
new[] { 2, 3, 4, 5, 6 }
};
Func<Grid>[] largeNumberImages = new Func<Grid>[10];
Func<Grid>[] smallNumberImages = new Func<Grid>[10];
for (int i = 0; i < 10; i++)
{
IReadOnlyList<int> layout = layouts[i];
largeNumberImages[i] = () =>
{
Grid grid = new Grid();
foreach (int n in layout)
{
grid.Children.Add(largeSegments[n]());
}
return grid;
};
smallNumberImages[i] = () =>
{
Grid grid = new Grid();
foreach (int n in layout)
{
grid.Children.Add(smallSegments[n]());
}
return grid;
};
}
Func<Grid> largeDotImage = () =>
{
Grid grid = new Grid();
grid.Children.Add(largeSegments[7]());
return grid;
};
Func<Grid> smallDotImage = () =>
{
Grid grid = new Grid();
grid.Children.Add(smallSegments[7]());
return grid;
};
Func<Grid> largeDashImage = () =>
{
Grid grid = new Grid();
grid.Children.Add(largeSegments[3]());
return grid;
};
Func<Grid> smallDashImage = () =>
{
Grid grid = new Grid();
grid.Children.Add(smallSegments[3]());
return grid;
};
this.largeNumberImage0 = largeNumberImages[0];
this.smallNumberImage0 = smallNumberImages[0];
this.largeNumberImage1 = largeNumberImages[1];
this.smallNumberImage1 = smallNumberImages[1];
this.largeNumberImage2 = largeNumberImages[2];
this.smallNumberImage2 = smallNumberImages[2];
this.largeNumberImage3 = largeNumberImages[3];
this.smallNumberImage3 = smallNumberImages[3];
this.largeNumberImage4 = largeNumberImages[4];
this.smallNumberImage4 = smallNumberImages[4];
this.largeNumberImage5 = largeNumberImages[5];
this.smallNumberImage5 = smallNumberImages[5];
this.largeNumberImage6 = largeNumberImages[6];
this.smallNumberImage6 = smallNumberImages[6];
this.largeNumberImage7 = largeNumberImages[7];
this.smallNumberImage7 = smallNumberImages[7];
this.largeNumberImage8 = largeNumberImages[8];
this.smallNumberImage8 = smallNumberImages[8];
this.largeNumberImage9 = largeNumberImages[9];
this.smallNumberImage9 = smallNumberImages[9];
this.largeDotImage = largeDotImage;
this.smallDotImage = smallDotImage;
this.largeDashImage = largeDashImage;
this.smallDashImage = smallDashImage;
Transaction.RunVoid(() => { this.implementation = new Implementation(this); });
}
public List <Cmd> CreateInitCmds(Implementation impl)
{
return(new List <Cmd>());
}
public override void Implement(MethodBodyTransformationContext context)
{
Implementation implementation = new Implementation(this, context);
implementation.Implement();
}
/// <inheritdoc />
public void Convert(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, int byteCount, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
{
Implementation.Convert(chars, charIndex, charCount, bytes, byteIndex, byteCount, flush, out charsUsed, out bytesUsed, out completed);
}
public SocialPostIntents()
{
Self = Implementation.Constructor();
}
public void TestNormalizeLocalPath()
{
var localUri = new FeedUri(WindowsUtils.IsWindows ? @"C:\local\feed.xml" : "/local/feed.xml");
var implementation1 = new Implementation {ID = "./subdir"};
implementation1.Normalize(localUri);
implementation1.ID
.Should().Be(WindowsUtils.IsWindows ? @"C:\local\.\subdir" : "/local/./subdir");
implementation1.LocalPath
.Should().Be(WindowsUtils.IsWindows ? @"C:\local\.\subdir" : "/local/./subdir");
var implementation2 = new Implementation {ID = "./wrong", LocalPath = "subdir"};
implementation2.Normalize(localUri);
implementation2.ID.Should().Be("./wrong");
implementation2.LocalPath
.Should().Be(WindowsUtils.IsWindows ? @"C:\local\subdir" : "/local/subdir");
}
private void ProcessWrapperImplementation(Implementation impl)
{
this.InternalImplementation = impl;
}
public async Task TestEmptyPages()
{
Implementation implementation = new Implementation();
await implementation.TestEmptyPages();
}
public void TestNormalizeRejectRelativeHref()
{
var relative = new Archive {Href = new Uri("relative", UriKind.Relative)};
var absolute = new Archive {Href = new Uri("http://server/absolute.zip", UriKind.Absolute)};
var implmementation = new Implementation {RetrievalMethods = {relative, absolute}};
implmementation.Normalize(FeedTest.Test1Uri);
implmementation.RetrievalMethods.Should().Equal(absolute);
}
public async Task TestResumingFromStateAsync()
{
Implementation implementation = new Implementation();
await implementation.TestResumingFromStateAsync();
}
static void Main(string[] args)
{
Implementation clas = new Implementation();
clas.StartWork();
}
public void TestNormalizeID()
{
var implementation = new Implementation {ID = "sha256=123"};
implementation.Normalize(FeedTest.Test1Uri);
Assert.AreEqual("123", implementation.ManifestDigest.Sha256);
implementation = new Implementation {ID = "sha256=wrong", ManifestDigest = new ManifestDigest(sha256: "correct")};
implementation.Normalize(FeedTest.Test1Uri);
Assert.AreEqual("correct", implementation.ManifestDigest.Sha256);
implementation = new Implementation {ID = "abc"};
implementation.Normalize(FeedTest.Test1Uri);
}
/// <inheritdoc />
public int GetByteCount(char[] chars, int index, int count, bool flush)
{
return(Implementation.GetByteCount(chars, index, count, flush));
}
public async Task Test429sWithContinuationsAsync()
{
Implementation implementation = new Implementation();
await implementation.Test429sWithContinuationsAsync();
}
public void TestNormalizeRejectLocalPath()
{
var implmementation = new Implementation {LocalPath = "subdir"};
implmementation.Normalize(FeedTest.Test1Uri);
implmementation.LocalPath.Should().BeNull();
}
/// <inheritdoc />
public int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush)
{
return(Implementation.GetBytes(chars, charIndex, charCount, bytes, byteIndex, flush));
}
public void TestNormalizeID()
{
var implementation = new Implementation {ID = "sha256=123"};
implementation.Normalize(FeedTest.Test1Uri);
implementation.ManifestDigest.Sha256.Should().Be("123");
implementation = new Implementation {ID = "sha256=wrong", ManifestDigest = new ManifestDigest(sha256: "correct")};
implementation.Normalize(FeedTest.Test1Uri);
implementation.ManifestDigest.Sha256.Should().Be("correct");
implementation = new Implementation {ID = "abc"};
implementation.Normalize(FeedTest.Test1Uri);
}
public DatacloudContacts()
{
Self = Implementation.Constructor();
}
public void TestNormalizeCommand()
{
var implementation = new Implementation {Main = "main", SelfTest = "test"};
implementation.Normalize(FeedTest.Test1Uri);
Assert.AreEqual("main", implementation[Command.NameRun].Path);
Assert.AreEqual("test", implementation[Command.NameTest].Path);
}
public TopicsCapabilityInput()
{
Self = Implementation.Constructor();
}
public void TestNormalizeLocalPath()
{
var localUri = new FeedUri(WindowsUtils.IsWindows ? @"C:\local\feed.xml" : "/local/feed.xml");
var implementation1 = new Implementation {ID = "./subdir"};
implementation1.Normalize(localUri);
Assert.AreEqual(
expected: WindowsUtils.IsWindows ? @"C:\local\.\subdir" : "/local/./subdir",
actual: implementation1.ID);
Assert.AreEqual(
expected: WindowsUtils.IsWindows ? @"C:\local\.\subdir" : "/local/./subdir",
actual: implementation1.LocalPath);
var implementation2 = new Implementation {ID = "./wrong", LocalPath = "subdir"};
implementation2.Normalize(localUri);
Assert.AreEqual(
expected: "./wrong",
actual: implementation2.ID);
Assert.AreEqual(
expected: WindowsUtils.IsWindows ? @"C:\local\subdir" : "/local/subdir",
actual: implementation2.LocalPath);
}
public override Implementation VisitImplementation(Implementation node)
{
node.Attributes = RemoveLayerAttribute(node.Attributes);
return(base.VisitImplementation(node));
}
public void TestNormalizeRejectRelativeHref()
{
var relative = new Archive {Href = new Uri("relative", UriKind.Relative)};
var absolute = new Archive {Href = new Uri("http://server/absolute.zip", UriKind.Absolute)};
var implmementation = new Implementation {RetrievalMethods = {relative, absolute}};
implmementation.Normalize(FeedTest.Test1Uri);
CollectionAssert.AreEqual(
expected: new[] {absolute},
actual: implmementation.RetrievalMethods);
}
public void TypeCheck()
{
foreach (var proc in program.Procedures)
{
if (!QKeyValue.FindBoolAttribute(proc.Attributes, "yields"))
{
continue;
}
int createdAtLayerNum; // must be initialized by the following code, otherwise it is an error
int availableUptoLayerNum = int.MaxValue;
List <int> attrs = FindLayers(proc.Attributes);
if (attrs.Count == 1)
{
createdAtLayerNum = attrs[0];
}
else if (attrs.Count == 2)
{
createdAtLayerNum = attrs[0];
availableUptoLayerNum = attrs[1];
}
else
{
Error(proc, "Incorrect number of layers");
continue;
}
if (availableUptoLayerNum <= createdAtLayerNum)
{
Error(proc, "Creation layer number must be less than the available upto layer number");
continue;
}
foreach (Ensures e in proc.Ensures)
{
MoverType moverType = GetMoverType(e);
if (moverType == MoverType.Top)
{
continue;
}
CodeExpr codeExpr = e.Condition as CodeExpr;
if (codeExpr == null)
{
Error(e, "An atomic action must be a CodeExpr");
continue;
}
if (procToActionInfo.ContainsKey(proc))
{
Error(proc, "A procedure can have at most one atomic action");
continue;
}
minLayerNum = int.MaxValue;
maxLayerNum = -1;
canAccessSharedVars = true;
enclosingProc = proc;
enclosingImpl = null;
base.VisitEnsures(e);
canAccessSharedVars = false;
if (maxLayerNum > createdAtLayerNum)
{
Error(e, "A variable being accessed is introduced after this action is created");
}
else if (availableUptoLayerNum > minLayerNum)
{
Error(e, "A variable being accessed is hidden before this action becomes unavailable");
}
else
{
procToActionInfo[proc] = new AtomicActionInfo(proc, e, moverType, createdAtLayerNum, availableUptoLayerNum);
}
}
if (errorCount > 0)
{
continue;
}
if (!procToActionInfo.ContainsKey(proc))
{
procToActionInfo[proc] = new ActionInfo(proc, createdAtLayerNum, availableUptoLayerNum);
}
}
if (errorCount > 0)
{
return;
}
foreach (var impl in program.Implementations)
{
if (!procToActionInfo.ContainsKey(impl.Proc))
{
continue;
}
procToActionInfo[impl.Proc].hasImplementation = true;
}
foreach (var proc in procToActionInfo.Keys)
{
ActionInfo actionInfo = procToActionInfo[proc];
if (actionInfo.isExtern && actionInfo.hasImplementation)
{
Error(proc, "Extern procedure cannot have an implementation");
continue;
}
if (actionInfo.isExtern || actionInfo.hasImplementation)
{
continue;
}
if (leastUnimplementedLayerNum == int.MaxValue)
{
leastUnimplementedLayerNum = actionInfo.createdAtLayerNum;
}
else if (leastUnimplementedLayerNum != actionInfo.createdAtLayerNum)
{
Error(proc, "All unimplemented atomic actions must be created at the same layer");
}
}
foreach (var g in this.globalVarToSharedVarInfo.Keys)
{
var info = globalVarToSharedVarInfo[g];
if (!this.AllCreatedLayerNums.Contains(info.introLayerNum))
{
Error(g, "Variable must be introduced with creation of some atomic action");
}
if (info.hideLayerNum != int.MaxValue && !this.AllCreatedLayerNums.Contains(info.hideLayerNum))
{
Error(g, "Variable must be hidden with creation of some atomic action");
}
}
if (errorCount > 0)
{
return;
}
this.VisitProgram(program);
foreach (Procedure proc in program.Procedures)
{
if (procToActionInfo.ContainsKey(proc))
{
continue;
}
foreach (var ie in proc.Modifies)
{
if (!SharedVariables.Contains(ie.Decl))
{
continue;
}
Error(proc, "A ghost procedure must not modify a global variable with layer annotation");
}
}
if (errorCount > 0)
{
return;
}
YieldTypeChecker.PerformYieldSafeCheck(this);
new LayerEraser().VisitProgram(program);
}
public void GenerateMissingArchive()
{
using (var tempDir = new TemporaryDirectory("0install-unit-tests"))
{
string feedPath = Path.Combine(tempDir, "feed.xml");
Directory.CreateDirectory(Path.Combine(tempDir, "impl"));
FileUtils.Touch(Path.Combine(tempDir, "impl", "file"));
var archive = new Archive {Href = new Uri("archive.zip", UriKind.Relative)};
var implementation = new Implementation {LocalPath = "impl", RetrievalMethods = {archive}};
implementation.AddMissing(new SilentTaskHandler(), new SimpleCommandExecutor {Path = feedPath});
implementation.LocalPath.Should().BeNull();
implementation.ManifestDigest.Should().NotBe(default(ManifestDigest));
archive.Size.Should().NotBe(0);
File.Exists(Path.Combine(tempDir, "archive.zip")).Should().BeTrue();
}
}
/// <summary>
/// Sets up the cosmetic data for this model, or, what's displayed in the GUI for the program.<para/>
/// This specific method populates data that is common across all imported models.
/// </summary>
/// <param name="model">The model containing other data, such as the <see cref="Implementation"/>.</param>
/// <param name="dataTreeParent">This is the instance in the data tree that represents this object in the hierarchy. If null, this method call is skipped.</param>
/// <param name="dataTreeNameIsImplementation">If <see langword="true"/>, the name of <paramref name="dataTreeParent"/> is the implementation of the model, so the implementation property will not be added.</param>
public static void SetupCosmeticInformation(ModelConfig model, DataTreeObject dataTreeParent, bool dataTreeNameIsImplementation)
{
if (dataTreeParent == null)
{
return;
}
Implementation impl = model.implementation;
if (!dataTreeNameIsImplementation)
{
// If this is true, the name of the actual node is the implementation, rendering this property useless.
string implementationName = JavaClassNameStripper.GetWholeClassName(impl.getClass().getName()) ?? "Unknown Implementation";
dataTreeParent.AddSimpleProperty("Implementation", implementationName.Replace("$", "::"), SilkImage.Config, SilkImage.Config, true);
}
// It's imported!
// ...Unless it's a CompoundConfig. (I mean given the properties below it makes sense, it's just a container, not actual model data.)
if (impl is Imported imported)
{
//RootDataTreeObject.AddSimpleProperty("Scale", model.scale);
List <object> influences = new List <object>(3);
if (imported.influences.fog)
{
influences.Add(new DataTreeObjectProperty("Fog", SilkImage.Shading));
}
if (imported.influences.lights)
{
influences.Add(new DataTreeObjectProperty("Lights", SilkImage.Light));
}
if (imported.influences.projections)
{
influences.Add(new DataTreeObjectProperty("Projections", SilkImage.Texture));
}
if (influences.Count > 0)
{
dataTreeParent.AddSimpleProperty("Influenced By...", influences.ToArray(), displaySinglePropertiesInline: false);
}
/*
* MaterialMapping[] matMaps = imported.materialMappings;
* object[] materialProperties = new object[matMaps.Length];
* for (int idx = 0; idx < materialProperties.Length; idx++) {
* ConfigReference mtlRef = matMaps[idx].material;
* ConfigReference texCfg = (ConfigReference)mtlRef.getArguments().getOrDefault("Texture", null);
* if (texCfg != null) {
* string texFile = (string)texCfg.getArguments().getOrDefault("File", "?");
* materialProperties[idx] = new DataTreeObjectProperty(texFile, SilkImage.Reference, false);
* } else {
* materialProperties[idx] = matMaps[idx].texture;
* }
* }
* dataTreeParent.AddSimpleProperty("Textures", materialProperties, SilkImage.Value, SilkImage.Texture, false);
*/
}
List <object> parameters = new List <object>();
foreach (Parameter prop in model.parameters)
{
if (prop is Parameter.Direct direct)
{
DataTreeObject paths = new DataTreeObject {
ImageKey = SilkImage.Tag,
Text = "Direct: " + direct.name
};
int idx = 0;
foreach (string path in direct.paths)
{
paths.AddSimpleProperty("Path " + idx, path);
idx++;
}
parameters.Add(paths);
}
else if (prop is Parameter.Choice choice)
{
DataTreeObject choices = new DataTreeObject {
ImageKey = SilkImage.Value,
Text = "Choice: " + choice.name + " [Default: " + choice.choice + "]"
};
List <DataTreeObject> choiceList = new List <DataTreeObject>();
foreach (Parameter.Choice.Option option in choice.options)
{
// choiceList.Add(c);
DataTreeObject choiceInfo = new DataTreeObject {
ImageKey = SilkImage.Tag,
Text = option.name
};
ArgumentMap args = option.arguments;
object[] keys = args.keySet().toArray();
foreach (object key in keys)
{
choiceInfo.AddSimpleProperty(key.ToString(), args.get(key));
}
choiceList.Add(choiceInfo);
}
choices.AddSimpleProperty("Choices", choiceList.ToArray(), SilkImage.Value, SilkImage.Tag, false);
List <DataTreeObject> subDirects = new List <DataTreeObject>();
foreach (Parameter.Direct dir in choice.directs)
{
DataTreeObject dirObj = new DataTreeObject {
ImageKey = SilkImage.Tag,
Text = "Direct: " + dir.name
};
int idx = 0;
foreach (string path in dir.paths)
{
dirObj.AddSimpleProperty("Path " + idx, path);
idx++;
}
subDirects.Add(dirObj);
}
choices.AddSimpleProperty("Choice Directs", subDirects.ToArray(), SilkImage.Value, SilkImage.Tag, false);
parameters.Add(choices);
}
else
{
parameters.Add($"{prop.name} [{prop.GetType().FullName}]");
}
}
dataTreeParent.AddSimpleProperty("Parameters", parameters.ToArray(), SilkImage.Value, SilkImage.Tag, false);
}
private SelectionCandidate GenerateDummyCandidate(FeedUri feedUri, FeedPreferences feedPreferences, Implementation implementation)
{
return new SelectionCandidate(feedUri, feedPreferences, implementation,
new Requirements(_interfaceUri, Command.NameRun, new Architecture(Architecture.CurrentSystem.OS, Cpu.All)));
}
public FeedElementCapabilitiesInput()
{
Self = Implementation.Constructor();
}
public MyFacade(Bank bank)
{
this.bank = bank;
this.impl = null;
}
public ModerationFlagsCollection()
{
Self = Implementation.Constructor();
}
public void AddMissingSingleFile()
{
using (var originalStream = SingleFileData.ToStream())
using (var microServer = new MicroServer(SingleFileName, originalStream))
{
var implementation = new Implementation {RetrievalMethods = {new SingleFile {Href = microServer.FileUri}}};
implementation.AddMissing(new SilentTaskHandler());
Assert.AreEqual(_singleFileSha256Digest, "sha256new_" + implementation.ManifestDigest.Sha256New);
var file = (SingleFile)implementation.RetrievalMethods[0];
Assert.AreEqual(originalStream.Length, file.Size);
Assert.AreEqual(SingleFileName, file.Destination);
}
}
public FeedFavorites()
{
Self = Implementation.Constructor();
}
internal Graph <Block> GetImplementationGraph(Implementation impl)
{
return(Microsoft.Boogie.Program.GraphFromImpl(impl));
}
public async Task TestMergeToSinglePartition()
{
Implementation implementation = new Implementation(true);
await implementation.TestMergeToSinglePartition();
}
