コード例 #1
0
        public void TestVariantFile3()
        {
            var main = new ModinfoData("Main")
            {
                Version      = new Version(1, 1, 1),
                Dependencies = new DependencyList(new IModReference[] { new ModReference {
                                                                            Identifier = "123", Type = ModType.Workshops
                                                                        } }, DependencyResolveLayout.FullResolved)
            };

            var file = ModinfoDataUtils.CreateVariantFile(new MockFileSystem(), "mods/A");

            IModinfoFile modinfoFile = new ModinfoVariantFile(file, main);

            Assert.Equal(ModinfoFileKind.VariantFile, modinfoFile.FileKind);

            Assert.Null(Record.Exception(modinfoFile.ValidateFile));
            Assert.Null(Record.Exception(modinfoFile.GetModinfo));
            Assert.Null(Record.ExceptionAsync(modinfoFile.GetModinfoAsync).Result);

            var data = modinfoFile.GetModinfo();

            Assert.Equal(new Version(1, 1, 1), data.Version);
            Assert.Single(data.Dependencies);
        }
コード例 #2
0
        public void TestVariantFile4()
        {
            var fs          = new MockFileSystem();
            var variantMain = new ModinfoVariantFile(ModinfoDataUtils.CreateVariantMainFile(fs, "mods/A"));
            var variant     = ModinfoDataUtils.CreateVariantFile(fs, "mods/A");

            Assert.Throws <ModinfoException>(() => new ModinfoVariantFile(variant, variantMain));
        }
コード例 #3
0
        public void Test6()
        {
            var fs       = new MockFileSystem(new Dictionary <string, MockFileData>());
            var mainFile = new MainModinfoFile(ModinfoDataUtils.CreateModifnoFile(fs, "mods/A"));

            Assert.Throws <ModinfoException>(() => new ModinfoFinderCollection(
                                                 fs.DirectoryInfo.FromDirectoryName("mods/A"), new[] { mainFile }));
        }
コード例 #4
0
        public void Test5()
        {
            var fs = new MockFileSystem(new Dictionary <string, MockFileData>());

            var variant = new ModinfoVariantFile(ModinfoDataUtils.CreateVariantMainFile(fs, "mods/A"));

            Assert.Throws <ModinfoException>(() =>
                                             new ModinfoFinderCollection(fs.DirectoryInfo.FromDirectoryName("mods/A"), variant));
        }
コード例 #5
0
        public void TestVariantFile1()
        {
            var          fileInfo    = ModinfoDataUtils.CreateVariantMainFile(new MockFileSystem(), "mods/A");
            IModinfoFile modinfoFile = new ModinfoVariantFile(fileInfo);

            Assert.Equal(ModinfoFileKind.VariantFile, modinfoFile.FileKind);

            Assert.Null(Record.Exception(modinfoFile.ValidateFile));
            Assert.Null(Record.Exception(modinfoFile.GetModinfo));
            Assert.Null(Record.ExceptionAsync(modinfoFile.GetModinfoAsync).Result);
        }
コード例 #6
0
        public void Test1()
        {
            var fs = new MockFileSystem(new Dictionary <string, MockFileData>());

            var mainFile   = new MainModinfoFile(ModinfoDataUtils.CreateModifnoFile(fs, "mods/A"));
            var collection = new ModinfoFinderCollection(fs.DirectoryInfo.FromDirectoryName("mods/A"), mainFile);

            Assert.Single(collection);
            Assert.NotNull(collection.MainModinfo);
            Assert.Empty(collection.Variants);
        }
コード例 #7
0
        public void Test2()
        {
            var fs = new MockFileSystem(new Dictionary <string, MockFileData>());

            var variant    = new ModinfoVariantFile(ModinfoDataUtils.CreateVariantMainFile(fs, "mods/A"));
            var collection = new ModinfoFinderCollection(
                fs.DirectoryInfo.FromDirectoryName("mods/A"), new[] { variant });

            Assert.Single(collection);
            Assert.Single(collection.Variants);
            Assert.Null(collection.MainModinfo);
        }
コード例 #8
0
        public void Test4()
        {
            var fs = new MockFileSystem(new Dictionary <string, MockFileData>());

            var variantFileInfo = ModinfoDataUtils.CreateVariantMainFile(fs, "mods/A");
            var variant         = new ModinfoVariantFile(variantFileInfo);
            var mainFile        = new MainModinfoFile(ModinfoDataUtils.CreateModifnoFile(fs, "mods/A"));
            var variantM        = new ModinfoVariantFile(variantFileInfo, mainFile);
            var collection      = new ModinfoFinderCollection(
                fs.DirectoryInfo.FromDirectoryName("mods/A"), mainFile, new[] { variant, variantM });

            Assert.Equal(3, collection.Count());
            Assert.Equal(2, collection.Variants.Count);
            Assert.NotNull(collection.MainModinfo);
        }
コード例 #9
0
        public void TestVariantFile2()
        {
            var fs = new MockFileSystem();

            var          mainFileInfo = ModinfoDataUtils.CreateModifnoFile(fs, "mods/A");
            IModinfoFile mainFile     = new MainModinfoFile(mainFileInfo);

            var          variantFileInfo = ModinfoDataUtils.CreateVariantFile(fs, "mods/A");
            IModinfoFile variantFile     = new ModinfoVariantFile(variantFileInfo, mainFile);

            Assert.Equal(ModinfoFileKind.VariantFile, variantFile.FileKind);

            Assert.Null(Record.Exception(variantFile.ValidateFile));
            Assert.Null(Record.Exception(variantFile.GetModinfo));
            Assert.Null(Record.ExceptionAsync(variantFile.GetModinfoAsync).Result);

            var data = variantFile.GetModinfo();

            Assert.Equal(new Version(1, 1, 1, "BETA"), data.Version);
            Assert.Single(data.Custom);
            Assert.Single(data.Languages);
        }