public void Execute(IPlatformFactory factory, ITestLogger logger) { var build = new GeomBuild(); MgPolygon geom1 = build.CreatePolygon(2.0); MgPolygon geom2 = build.CreatePolygon(12.0); MgPolygon geom3 = build.CreatePolygon(2.0); MgPolygonCollection coll = new MgPolygonCollection(); coll.Add(geom1); coll.Add(geom2); coll.Add(geom3); Assert.AreEqual(3, coll.Count); Assert.IsTrue(geom1.Equals(coll[0])); Assert.IsTrue(coll[0].Equals(coll[2])); Assert.IsFalse(coll[0].Equals(coll[1])); coll[0] = coll[1]; Assert.IsTrue(coll[0].Equals(coll[1])); double width = 0.0; foreach (MgPolygon geom in coll) { width += geom.Envelope().GetWidth(); } Assert.AreEqual(geom1.Envelope().GetWidth() * 3.0, width); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgDataPropertyDefinition def1 = new MgDataPropertyDefinition("def1"); MgDataPropertyDefinition def2 = new MgDataPropertyDefinition("def2"); MgDataPropertyDefinition def3 = new MgDataPropertyDefinition("def3"); MgDataPropertyDefinition def4 = new MgDataPropertyDefinition("def4"); MgPropertyDefinitionCollection coll = new MgPropertyDefinitionCollection(); coll.Add(def1); coll.Add(def2); coll.Insert(2, def4); coll.Insert(2, def3); Assert.AreEqual(4, coll.Count); Assert.AreEqual("def1", coll[0].GetName()); MgPropertyDefinition tmp = coll[0]; coll.Remove(def1); Assert.AreEqual(3, coll.Count); coll.Insert(0, tmp); string txt = ""; foreach (MgPropertyDefinition def in coll) { txt += "[" + def.GetName() + "]"; } Assert.AreEqual("[def1][def2][def3][def4]", txt); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { string coordsys = "GEOGCS[\"LL84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9108\"]],AXIS[\"Lat\",NORTH],AXIS[\"Long\",EAST],AUTHORITY[\"EPSG\",\"4326\"]]"; MgEnvelope env = new MgEnvelope(10, 10, 20, 20); MgMapBase map1 = factory.CreateMap(coordsys, env, "map1"); MgMapBase map2 = factory.CreateMap(coordsys, env, "map2"); MgMapBase map3 = factory.CreateMap(coordsys, env, "map3"); MgMapBase map4 = factory.CreateMap(coordsys, env, "map4"); MgMapCollection coll = new MgMapCollection(); coll.Add(map1); coll.Insert(1, map2); coll.Add(map3); Assert.AreEqual(3, coll.Count); Assert.AreEqual(coll[2].GetName(), "map3"); coll[1] = map4; string txt = ""; foreach (MgMapBase map in coll) { txt += "[" + map.GetName() + "]"; } Assert.AreEqual("[map1][map4][map3]", txt); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { var wkt = new MgWktReaderWriter(); MgPoint geom1 = wkt.Read("POINT XY (1.0 1.0)") as MgPoint; MgPoint geom2 = wkt.Read("POINT XY (2.0 2.0)") as MgPoint; MgPoint geom3 = wkt.Read("POINT XY (1.0 1.0)") as MgPoint; MgPointCollection coll = new MgPointCollection(); coll.Add(geom1); coll.Add(geom2); coll.Add(geom3); Assert.AreEqual(3, coll.Count); Assert.IsTrue(geom1.Equals(coll[0])); Assert.IsTrue(coll[0].Equals(coll[2])); Assert.IsFalse(coll[0].Equals(coll[1])); coll[0] = coll[1]; Assert.IsTrue(coll[0].Equals(coll[1])); double x = 0.0; foreach (MgPoint geom in coll) { x += geom.GetCoordinate().GetX(); } Assert.AreEqual(5.0, x); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { logger.WriteLine("Skipping CollectionTestsLayerCollection: MgLayerGroupCollection constructor not visible"); /* * MgLayerGroup group1 = new MgLayerGroup("group1"); * MgLayerGroup group2 = new MgLayerGroup("group2"); * MgLayerGroup group3 = new MgLayerGroup("group3"); * MgLayerGroup group4 = new MgLayerGroup("group4"); * * MgLayerGroupCollection coll = new MgLayerGroupCollection(); * coll.Add(group1); * coll.Insert(1, group2); * coll.Add(group3); * coll.Insert(3, group4); * * Assert.AreEqual(4, coll.Count); * Assert.AreEqual(coll[2].GetName(), "group3"); * * coll[1] = coll[2]; * * string txt = ""; * foreach (MgLayerGroup group in coll) * { * txt += "[" + group.GetName() + "]"; * } * Assert.AreEqual("[group1][group3][group3][group4]", txt); */ }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgPropertyCollection propVals = new MgPropertyCollection(); MgInt32Property prop = new MgInt32Property("prop", 1); propVals.Add(prop); MgUpdateFeatures update = new MgUpdateFeatures("class2", propVals, "where cat < dog"); MgInsertFeatures insert = new MgInsertFeatures("class3", propVals); MgDeleteFeatures del = new MgDeleteFeatures("class1", "where cat > dog"); MgFeatureCommandCollection coll = new MgFeatureCommandCollection(); coll.Add(update); coll.Add(insert); coll.Add(del); Assert.AreEqual(3, coll.Count); Assert.AreEqual(MgFeatureCommandType.DeleteFeatures, coll[2].GetCommandType()); coll[0] = coll[1]; string txt = ""; foreach (MgFeatureCommand cmd in coll) { txt += "[" + cmd.GetCommandType() + "]"; } Assert.AreEqual("[0][0][2]", txt); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgGeometryFactory gf = new MgGeometryFactory(); MgCoordinate c1 = gf.CreateCoordinateXY(1.0, 1.0); MgCoordinate c2 = gf.CreateCoordinateXY(2.0, 2.0); MgCoordinate c3 = gf.CreateCoordinateXY(3.0, 3.0); MgCoordinate c4 = gf.CreateCoordinateXY(4.0, 4.0); MgCoordinateCollection coll = new MgCoordinateCollection(); coll.Add(c1); coll.Insert(1, c2); coll.Add(c3); coll.Add(c4); Assert.AreEqual(4, coll.Count); Assert.AreEqual(1.0, coll[0].GetX()); coll[3] = coll[2]; Assert.AreEqual(3.0, coll[3].GetX()); double sum = 0.0; foreach (MgCoordinate coord in coll) { sum += coord.GetX(); } Assert.AreEqual(9.0, sum); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { StringCollection strColl = new StringCollection(); strColl.Add("string1"); strColl.Add("string2"); strColl.Add("string3"); strColl.Add("string3"); MgStringCollection coll1 = new MgStringCollection(); coll1.Add("Hello"); MgStringCollection coll2 = new MgStringCollection(strColl); Assert.AreEqual(4, coll2.GetCount()); StringCollection coll3 = coll2; Assert.AreEqual(4, coll3.Count); for (int i = 0; i < 4; i++) { Assert.AreEqual(strColl[i], coll2.GetItem(i)); Assert.AreEqual(strColl[i], coll3[i]); } }
public static int Execute(IPlatformFactory factory, ITestLogger logger, ref int testsRun) { int failures = 0; var types = typeof(MapGuideTests).Assembly.GetTypes(); foreach (var type in types) { if (typeof(IExternalTest).IsAssignableFrom(type) && type.IsClass && !type.IsAbstract) { var test = (IExternalTest)Activator.CreateInstance(type); try { logger.WriteLine("****** Executing MapGuide test: " + type.Name + " *********"); Console.WriteLine("Executing external MapGuide test: " + type.Name); test.Execute(factory, logger); } catch (AssertException ex) { logger.WriteLine("Assertion failure: " + ex.Message); failures++; } catch (Exception ex) { logger.WriteLine("General failure: " + ex.ToString()); failures++; } finally { testsRun++; } } } return(failures); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgStringProperty prop1 = new MgStringProperty("prop1", "val1"); MgStringProperty prop2 = new MgStringProperty("prop2", "val2"); MgStringProperty prop3 = new MgStringProperty("prop3", "val3"); MgStringProperty prop4 = new MgStringProperty("prop4", "val4"); MgStringPropertyCollection coll = new MgStringPropertyCollection(); coll.Add(prop1); coll.Add(prop2); coll.Remove(prop3); coll.Remove(coll[1]); Assert.AreEqual(1, coll.Count); coll.Add(prop3); coll[1] = prop2; coll.Insert(2, prop3); Assert.AreEqual(2, coll.IndexOf(prop3)); coll.Add(prop4); string txt = ""; foreach (MgStringProperty prop in coll) { txt += "[" + prop.GetName() + "]"; } Assert.AreEqual("[prop1][prop2][prop3][prop4]", txt); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgGeometryFactory gf = new MgGeometryFactory(); MgCoordinate pt1 = gf.CreateCoordinateXY(0, 0); MgCoordinate pt2 = gf.CreateCoordinateXY(0, 10); MgCoordinate pt3 = gf.CreateCoordinateXY(10, 10); MgCoordinate pt4 = gf.CreateCoordinateXY(10, 0); MgCoordinateCollection coordinates = new MgCoordinateCollection(); coordinates.Add(pt1); coordinates.Add(pt2); coordinates.Add(pt3); coordinates.Add(pt4); MgLinearSegment linearSegment = gf.CreateLinearSegment(coordinates); MgCurveSegmentCollection curveSegments = new MgCurveSegmentCollection(); curveSegments.Add(linearSegment); MgCurveString curveString = gf.CreateCurveString(curveSegments); Assert.AreEqual(1, curveString.Count); Assert.AreEqual(pt1.ToString(), curveString.StartCoordinate.ToString()); Assert.AreEqual(pt4.ToString(), curveString.EndCoordinate.ToString()); Assert.AreEqual(MgGeometryType.CurveString, curveString.GeometryType); Assert.AreEqual(1, curveString.Dimension); }
public TeamCityAndTrxLogger() { _teamCityLogger = new TeamCityLogger(); var trxLoggerType = Type.GetType("Microsoft.VisualStudio.TestPlatform.Extensions.TrxLogger, Microsoft.VisualStudio.TestPlatform.Extensions.TrxLogger, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"); _trxLogger = (ITestLogger)Activator.CreateInstance(trxLoggerType, true); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgGeometryFactory gf = new MgGeometryFactory(); MgCoordinate pt1 = gf.CreateCoordinateXY(0, 0); MgCoordinate pt2 = gf.CreateCoordinateXY(0, 10); MgCoordinate pt3 = gf.CreateCoordinateXY(10, 10); MgCoordinate pt4 = gf.CreateCoordinateXY(10, 0); MgCoordinateCollection coordinates = new MgCoordinateCollection(); coordinates.Add(pt1); coordinates.Add(pt2); coordinates.Add(pt3); coordinates.Add(pt4); MgLinearSegment linearSegment = gf.CreateLinearSegment(coordinates); MgCurveSegmentCollection curveSegments = new MgCurveSegmentCollection(); MgCurveRing curveRing = gf.CreateCurveRing(curveSegments); MgCurvePolygon cp = gf.CreateCurvePolygon(curveRing, null); MgCurvePolygonCollection cpc = new MgCurvePolygonCollection(); cpc.Add(cp); MgMultiCurvePolygon mcp = gf.CreateMultiCurvePolygon(cpc); Assert.AreEqual(1, mcp.Count); Assert.AreEqual(MgGeometryType.MultiCurvePolygon, mcp.GeometryType); Assert.AreEqual(2, mcp.Dimension); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgGeometryFactory gf = new MgGeometryFactory(); MgCoordinate pt1 = gf.CreateCoordinateXY(0, 0); MgCoordinate pt2 = gf.CreateCoordinateXY(0, 10); MgCoordinate pt3 = gf.CreateCoordinateXY(10, 10); MgCoordinate pt4 = gf.CreateCoordinateXY(10, 0); MgCoordinateCollection coordinates = new MgCoordinateCollection(); coordinates.Add(pt1); coordinates.Add(pt2); coordinates.Add(pt3); coordinates.Add(pt4); MgLinearSegment linearSegment = gf.CreateLinearSegment(coordinates); MgCurveSegmentCollection curveSegments = new MgCurveSegmentCollection(); curveSegments.Add(linearSegment); MgCurveString curveString = gf.CreateCurveString(curveSegments); MgCurveStringCollection csc = new MgCurveStringCollection(); csc.Add(curveString); MgMultiCurveString mcs = gf.CreateMultiCurveString(csc); Assert.AreEqual(1, mcs.Count); Assert.AreEqual(MgGeometryType.MultiCurveString, mcs.GeometryType); Assert.AreEqual(1, mcs.Dimension); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgGeometryFactory gf = new MgGeometryFactory(); MgCoordinate pt1 = gf.CreateCoordinateXY(0, 0); MgCoordinate pt2 = gf.CreateCoordinateXY(0, 10); MgCoordinate pt3 = gf.CreateCoordinateXY(10, 10); MgCoordinate pt4 = gf.CreateCoordinateXY(10, 0); MgCoordinateCollection coordinates = new MgCoordinateCollection(); coordinates.Add(pt1); coordinates.Add(pt2); coordinates.Add(pt3); coordinates.Add(pt4); MgLinearSegment linearSegment = gf.CreateLinearSegment(coordinates); MgCurveSegmentCollection curveSegments = new MgCurveSegmentCollection(); curveSegments.Add(linearSegment); MgCurveRing outerRing = gf.CreateCurveRing(curveSegments); MgCurvePolygon cp = gf.CreateCurvePolygon(outerRing, null); Assert.AreEqual(outerRing.ToString(), cp.ExteriorRing.ToString()); Assert.AreEqual(0, cp.InteriorRingCount); Assert.AreEqual(MgGeometryType.CurvePolygon, cp.GeometryType); Assert.AreEqual(2, cp.Dimension); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgStringProperty sp = new MgStringProperty("TestStringName", "TestStringValue"); Assert.AreEqual("TestStringValue", sp.Value); Assert.AreEqual("TestStringName", sp.Name); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgDeleteFeatures df = new MgDeleteFeatures("dfClassName", "dfFilterText"); Assert.AreEqual("dfClassName", df.FeatureClassName); Assert.AreEqual("dfFilterText", df.FilterText); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { ByteReaderTestData.Init(); var nBytes = ByteReaderTestData.nBytes; var nBlocks = ByteReaderTestData.nBlocks; var testBytes = ByteReaderTestData.testBytes; var infileName = ByteReaderTestData.infileName; var outfileName = ByteReaderTestData.outfileName; byte[] buf = new byte[nBytes]; MgByteReader reader = new MgByteReader(infileName, "png", false); Assert.AreEqual(nBlocks * nBytes, reader.GetLength()); reader.Read(buf, nBytes); Assert.AreEqual(buf, testBytes); Assert.AreEqual((nBlocks - 1) * nBytes, reader.GetLength()); reader.Rewind(); Assert.AreEqual(nBlocks * nBytes, reader.GetLength()); reader.ToFile(outfileName); reader.Rewind(); byte[] buf2 = new byte[nBytes]; System.IO.FileStream fp = System.IO.File.OpenRead(outfileName); for (int j = 0; j < nBlocks; j++) { fp.Read(buf2, 0, nBytes); reader.Read(buf, nBytes); Assert.AreEqual(buf, buf2); } fp.Close(); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgLayerGroup lg = new MgLayerGroup("TestLayerGroupName"); Assert.AreEqual("TestLayerGroupName", lg.Name); Assert.AreEqual(MgLayerGroupType.Normal, lg.LayerGroupType); lg.Group = new MgLayerGroup("AnotherTestLayerGroupName"); Assert.AreEqual("AnotherTestLayerGroupName", lg.Group.Name); lg.Visible = true; Assert.IsTrue(lg.Visible); lg.Visible = false; Assert.IsFalse(lg.Visible); lg.DisplayInLegend = true; Assert.IsTrue(lg.DisplayInLegend); lg.DisplayInLegend = false; Assert.IsFalse(lg.DisplayInLegend); Assert.IsFalse(lg.ExpandInLegend); lg.LegendLabel = "TestLegendLabel"; Assert.AreEqual("TestLegendLabel", lg.LegendLabel); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgFileFeatureSourceParams csp = new MgFileFeatureSourceParams(); csp.ProviderName = "OSGeo.SDF"; Assert.AreEqual("OSGeo.SDF", csp.ProviderName); csp.SpatialContextName = "TestSpatialContextName"; Assert.AreEqual("TestSpatialContextName", csp.SpatialContextName); csp.SpatialContextDescription = "TestSpatialContextDescription"; Assert.AreEqual("TestSpatialContextDescription", csp.SpatialContextDescription); csp.CoordinateSystemWkt = "TestCoordSysWkt"; Assert.AreEqual("TestCoordSysWkt", csp.CoordinateSystemWkt); csp.XYTolerance = 0.0001; Assert.AreEqual(0.0001, csp.XYTolerance); csp.ZTolerance = 0.01; Assert.AreEqual(0.01, csp.ZTolerance); MgFeatureSchema schema = new MgFeatureSchema("SchemaName", "SchemaDescription"); csp.FeatureSchema = schema; Assert.AreEqual(schema.Name, csp.FeatureSchema.Name); Assert.AreEqual(schema.Description, csp.FeatureSchema.Description); }
public Settings(string name, string configFile, Func<string, bool> fileExists, string baseDirectory, ITestLogger logger) { Name = name; Logger = logger; try { Directory = Path.GetDirectoryName(configFile); SettingsFile = configFile; Json.PopulateFromFile(SettingsFile, this); Name = Name ?? name; BatchInterval = BatchInterval ?? 250; if (AreValid) { LogDirectory = GetFullPath(LogDirectory ?? ""); if (LogToFile) { logger.AddLogger(LogFilePath); } } else { LogDirectory = ""; LogToFile = false; } } catch (Exception ex) { _validator.Validate(false, "Could not read settings: {0}", ex.Message); logger.Error(ex, "Could not read settings"); } }
public static void AddLogger(this ITestLogger logger, ITestLogger childLogger) { if (logger != null) { logger.AddLogger(l => l == childLogger, () => childLogger); } }
public void Execute(IPlatformFactory factory, ITestLogger logger) { string tmp = Path.GetTempFileName(); try { File.WriteAllText(tmp, "Hello World"); MgByteSource bs = new MgByteSource(tmp); MgByteReader reader = bs.GetReader(); MgGeometryProperty gp = new MgGeometryProperty("GeomPropName", reader); MgByteSource bs2 = new MgByteSource("../../TestData/DrawingService/SpaceShip.dwf"); MgByteReader reader2 = bs2.GetReader(); gp.Value = reader2; Assert.AreEqual(reader2.GetLength(), gp.Value.GetLength()); Assert.AreEqual(MgPropertyType.Geometry, gp.PropertyType); } finally { try { File.Delete(tmp); } catch { } } }
/// <summary> /// Executes the Unit Test /// </summary> /// <param name="logger">The logger.</param> public void Test(ITestLogger logger) { Logger = logger; var timer = new TestActionTimer(logger); LoadConfigurationSettingsOnce(this); InitializeEntityIds(); if (EntityIdsByLogicalName != null && EntityIdsByLogicalName.Count > 0) { timer.Time(PopulateEntityReferences, "Initialization Entity Reference (ms): "); } using (var internalService = GetInternalOrganizationServiceProxy()) { // ReSharper disable once AccessToDisposedClosure timer.Time(() => CleanupTestData(internalService, false), "Cleanup PreTestData (ms): "); try { // ReSharper disable once AccessToDisposedClosure timer.Time(() => AssumedEntities = AssumedEntities.Load(internalService, GetType()), "Load Assumptions (ms): "); var service = GetIOrganizationService(); AssertCrm = new AssertCrm(service); timer.Time(() => InitializeTestData(service), "Initialize TestData (ms): "); timer.Time(() => Test(service), "Run Test (ms): "); } finally { // ReSharper disable once AccessToDisposedClosure timer.Time(() => CleanupTestData(internalService, true), "Cleanup PostTestData (ms): "); } } }
private async Task<int> DiscoverTests(TestSourceSettings settings, ITestLogger logger, ITestCaseDiscoverySink discoverySink) { logger = new TestLogger(logger, settings.Name, "Discover"); var count = 0; var tests = new ConcurrentBag<Guid>(); if (settings.Port > 0) { logger.Debug("Start"); var discoverCommand = new DiscoverCommand(settings.Port); await discoverCommand.Run(spec => { var testCase = CreateTestCase(settings, spec); tests.Add(testCase.Id); discoverySink.SendTestCase(testCase); count += 1; }); await new RequestRunCommand(settings.Port).Run(tests); logger.Debug("Complete: {0} tests", count); } else { logger.Error("Not connected to {0}", TestAdapterInfo.Name); } return count; }
public void SaveTestRun( Guid buildId, Guid suiteRunId, string suiteType, string testName, string clientConfig, string serverConfig, string backendType, int executionTimeSecs, string status, string log, bool isRepeated) { ITestLogger logger = (ITestLogger) Activator.GetObject(typeof(ITestLogger), mServerLoggerUrl); logger.SaveTestRun( buildId, suiteRunId, suiteType, testName, clientConfig, serverConfig, backendType, executionTimeSecs, status, log, isRepeated); }
public Guid SaveBuild(string type, string name, string changeset, string comment) { ITestLogger logger = (ITestLogger) Activator.GetObject(typeof(ITestLogger), mServerLoggerUrl); return(logger.SaveBuild(type, name, changeset, comment)); }
public bool CheckConnection() { ITestLogger logger = (ITestLogger) Activator.GetObject(typeof(ITestLogger), mServerLoggerUrl); return(logger.CheckConnection()); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgPropertyCollection coll = new MgPropertyCollection(); MgDoubleProperty dblProp = new MgDoubleProperty("DoubleProp", 1.1111); MgInt32Property intProp = new MgInt32Property("IntProp", 1); MgDateTime dateTime = new MgDateTime(2006, 9, 21); MgDateTimeProperty dateProp = new MgDateTimeProperty("DateProp", dateTime); MgSingleProperty single = new MgSingleProperty("SingleProp", (float)2.2222); coll.Add(dblProp); coll.Add(intProp); coll.Add(dateProp); coll[2] = single; Assert.AreEqual(1.1111, (coll[0] as MgDoubleProperty).GetValue()); Assert.AreEqual(MgPropertyType.Double, coll[0].GetPropertyType()); Assert.AreEqual(MgPropertyType.Int32, coll[1].GetPropertyType()); Assert.AreEqual(MgPropertyType.Single, coll[2].GetPropertyType()); Assert.AreEqual((float)2.2222, (coll[2] as MgSingleProperty).GetValue()); Assert.AreEqual(3, coll.Count); Assert.AreEqual(MgPropertyType.Double, coll[0].GetPropertyType()); string str = ""; foreach (MgProperty prop in coll) { str = str + "[" + prop.GetName() + "]"; } Assert.AreEqual("[DoubleProp][IntProp][SingleProp]", str); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgDataPropertyDefinition dpd = new MgDataPropertyDefinition("DataPropDefName"); dpd.DataType = MgPropertyType.Int32; Assert.AreEqual(MgPropertyType.Int32, dpd.DataType); dpd.Length = 0; Assert.AreEqual(0, dpd.Length); dpd.Precision = 0; Assert.AreEqual(0, dpd.Precision); dpd.Scale = 0; Assert.AreEqual(0, dpd.Scale); dpd.DefaultValue = "123"; Assert.AreEqual("123", dpd.DefaultValue); dpd.Nullable = true; Assert.IsTrue(dpd.Nullable); dpd.ReadOnly = false; Assert.IsFalse(dpd.ReadOnly); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgFeatureProperty fp = new MgFeatureProperty("FeatureProp", null); Assert.AreEqual("FeatureProp", fp.Name); Assert.AreEqual(MgPropertyType.Feature, fp.PropertyType); Assert.IsNull(fp.Value); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgSingleProperty sp = new MgSingleProperty("SinglePropName", 4.251973f); Assert.AreEqual("SinglePropName", sp.Name); Assert.AreEqual(MgPropertyType.Single, sp.PropertyType); Assert.AreEqual(4.251973f, sp.Value); }
public void Execute(IPlatformFactory factory, ITestLogger logger) { MgRasterProperty rp = new MgRasterProperty("RasterPropName", null); Assert.AreEqual("RasterPropName", rp.Name); Assert.AreEqual(MgPropertyType.Raster, rp.PropertyType); Assert.IsNull(rp.Value); }
public JasmineServer(Settings settings, ITestLogger logger) : base(logger) { if (!settings.AreValid) { throw new ArgumentException("Settings are not valid", "settings"); } Settings = settings; }
public GTestRunner(ITestLogger logger, bool async = true) { _async = async; _logger = logger; _worker = new BackgroundWorker(); _worker.WorkerSupportsCancellation = true; _worker.DoWork += WorkerDoWork; _worker.RunWorkerCompleted += WorkerCompleted; }
public IEnumerable<ITestSuite> ConvertToGTest(TestCase[] cases, ITestLogger logger) { logger.Information("Converting Visual Studio TestCases to TestSuite"); Dictionary<string, ITestSuite> testSuites = new Dictionary<string, ITestSuite>(); foreach (var testCase in cases) { logger.Information(string.Format("Processing TestCase {0}", testCase.FullyQualifiedName)); if (!testSuites.ContainsKey(testCase.Source)) { logger.Information(string.Format("No existing source for {0}. Creating one...", testCase.Source)); testSuites[testCase.Source] = _factory.BuildTestSuite(testCase.Source, testCase.Source); } ITestSuite suite = testSuites[testCase.Source]; string[] splits = testCase.FullyQualifiedName.Split('.'); string caseName = splits[0]; string testName = splits[1]; logger.Information(string.Format("Searching for test case {0}...", caseName)); ITestCase foundCase = null; foreach (var @case in suite.TestCases) { if (@case.Name == caseName) { logger.Information(string.Format("Found test case {0}.", caseName)); foundCase = @case; } } if (foundCase == null) { logger.Information(string.Format("Did not find test case {0}. Creating it now...", caseName)); foundCase = _factory.BuildTestCase(suite, caseName); suite.AddTestCase(foundCase); } logger.Information(string.Format("Adding test {0}...", testName)); foundCase.AddTest(_factory.BuildTest(foundCase, testName)); } logger.Information("Preparing conversion result..."); var suites = testSuites.Values; logger.Information(string.Format("Conversion complete. Converted {0} suites.", suites.Count)); return suites; }
public KarmaSettings(string name, string configFile, Func<string, bool> fileExists, string baseDirectory, ITestLogger logger) { HasSettingsFile = false; Name = name; Logger = logger; try { Directory = Path.GetDirectoryName(configFile); SettingsFile = GetFullPath(Globals.SettingsFilename); KarmaConfigFile = GetFullPath(Globals.KarmaConfigFilename); if (PathUtils.PathHasFileName(configFile, Globals.SettingsFilename)) { Json.PopulateFromFile(configFile, this); KarmaConfigFile = string.IsNullOrWhiteSpace(KarmaConfigFile) ? GetFullPath(Globals.KarmaConfigFilename) : GetFullPath(KarmaConfigFile); _validator.Validate(fileExists(SettingsFile), "Settings file not found: {0}", PathUtils.GetRelativePath(baseDirectory, SettingsFile)); _validator.Validate(fileExists(KarmaConfigFile), "Karma configuration file not found: {0}", PathUtils.GetRelativePath(baseDirectory, KarmaConfigFile)); HasSettingsFile = true; } else { KarmaConfigFile = GetFullPath(configFile); _validator.Validate(fileExists(KarmaConfigFile), "Karma configuration file not found: {0}", PathUtils.GetRelativePath(baseDirectory, KarmaConfigFile)); } Name = Name ?? name; if (AreValid) { LogDirectory = GetFullPath(LogDirectory ?? ""); if (LogToFile) { logger.AddLogger(LogFilePath); } } else { LogDirectory = ""; LogToFile = false; } } catch (Exception ex) { _validator.Validate(false, "Could not read settings: {0}", ex.Message); logger.Error(ex, "Could not read settings"); } }
public int RunTests(string testName, ITestLogger logger, ref int testsRun) { TestResult actualResult = null; int exitStatus = 0; try { //Add the test in the log file string msg = "\n\n************************************************************\n" + string.Format("Executing {0}\n", testName) + "************************************************************\n\n"; logger.Write(msg); //Get the list of operations to be executed for this test. This list should comma separated, no spaces. _unitTestVm.Execute("Select ParamSets from TestCase where TestName=\"{0}\"", testName); string sets = _unitTestVm.GetString("ParamSets"); //Extract the paramset ids int[] paramSet = sets.Split(',').Where(x => !string.IsNullOrEmpty(x)).Select(x => Convert.ToInt32(x)).ToArray(); foreach (int paramSetId in paramSet) { _unitTestVm.Execute("Select ParamValue from Params where ParamSet={0} AND ParamName=\"OPERATION\"", paramSetId); string paramValue = _unitTestVm.GetString("ParamValue"); testsRun++; //Add the operation to the log file AddLogFileEntry(logger, paramValue, paramSetId, _unitTestResultVm); var exec = _executors.GetTestExecutor(paramValue); actualResult = exec.Execute(paramSetId); exitStatus += _executors.ValidateRequest(_unitTestDb, testName, paramSetId, paramValue, actualResult, logger); } return exitStatus; } catch (MgException ex) { throw new UnitTestException(string.Format("Exception from MapGuide:\n{0}", ex.GetDetails())); } }
protected TestContainerDiscoverer( IServiceProvider serviceProvider, ITestsService testsService, TestSettingsProvider testSettingsProvider, ITestLogger logger ) { Logger = logger; try { TestSettingsProvider = testSettingsProvider; TestAdapterInfo = CreateTestAdapterInfo(); Containers = new TestContainerList(this); ServiceProvider = serviceProvider; _testsService = testsService; SolutionListener = new SolutionListener(serviceProvider); SolutionListener.SolutionLoaded += OnSolutionLoaded; SolutionListener.SolutionUnloaded += OnSolutionUnloaded; SolutionListener.ProjectChanged += OnSolutionProjectChanged; SolutionListener.StartListening(); ProjectListener = new ProjectListener(serviceProvider, Logger); ProjectListener.FileAdded += (source, e) => OnProjectFileAdded(e.Project, e.File); ProjectListener.FileRemoved += (source, e) => OnProjectFileRemoved(e.Project, e.File); ProjectListener.FileRenamed += (source, e) => OnProjectFileRenamed(e.Project, e.OldFile, e.NewFile); ProjectListener.StartListening(); RunScheduler = new Scheduler(250, RunTestsInternal); RefreshTestContainersScheduler = new Scheduler<string>(250, RefreshTestContainersInternal); Logger.Debug("TestContainerDiscoverer created"); } catch (Exception ex) { Logger.Error(ex); throw; } }
public GTestRunOutputParser(ITestSuite testSuite, ITestLogger logger) { _expectedTests = new Dictionary<string, ITest>(); foreach (var testCase in testSuite.TestCases) { foreach (var test in testCase.Tests) { var runName = GTestNameFormatter.GetRunName(test); if (!_expectedTests.ContainsKey(runName)) { _expectedTests.Add(GTestNameFormatter.GetRunName(test), test); } else { logger.Warning(string.Format("Seem to have multiple test cases with the same name... Skipping {0}", runName)); } } } _currentTestRun = new StringBuilder(); _logger = logger; }
private static void AddLogFileEntry(ITestLogger logger, string operation, int paramSetId, SqliteVm vm) { logger.Write("\nParamSet: {0}\n", paramSetId); int status = vm.Execute("Select * from Params where ParamSet={0}", paramSetId); while (status == Sqlite.Row) { string paramName = vm.GetString("ParamName"); string paramValue = vm.GetString("ParamValue"); logger.Write("{0}: {1}\n", paramName, paramValue); status = vm.NextRow(); } }
public override int ValidateRequest(SqliteDotNet.SqliteDb db, string testName, int paramSetId, string operation, TestResult actualResult, ITestLogger logger) { int exitStatus = 0; string outcome = "pass"; SqliteVm vm = new SqliteVm(db, false); object expectedResult = null; //If we have an exception we need to remove the stack trace because different line numbers will fail the test object resultData = CommonUtility.RemoveStackTraceFromResult(actualResult.ResultData); //Get the mime type based on the content type in the result string mimeType = actualResult.ContentType; //If we have exception message we need to remove any parts that may contain system dependent information //Ex. file paths resultData = CommonUtility.ProcessExceptionMessage(resultData); //Get the file extension that will be used for a dump string actualExtension = CommonUtility.GetExtensionFromMimeType(mimeType); //If we have an ALWAYSPASS parameter defined for the operation then skip the whole validation process //This parameter should only be used for clean up operations that are no related with the tests if (vm.Execute("Select ParamValue from Params where ParamName=\"ALWAYSPASS\" and ParamSet={0}", paramSetId) != Sqlite.Row) { //TestName is Test_[ServiceType] string type = testName.Substring(testName.IndexOf("_") + 1); string filePath = CommonUtility.GetPath(string.Format("../../TestData/{0}/DumpFiles/{0}ApiTest", type)); string fileName = string.Format("{0}_{1}.{2}", filePath, paramSetId, actualExtension); if (this.TestExecutionMode == "dump") { //File.WriteAllText(fileName, resultData); throw new NotImplementedException("The .net test runner does not support dumping of test results. Please use the PHP test runner for this purpose"); } else { //This section is special case handling for the operations that return different data after each call resultData = CommonUtility.SpecialDataHandling(operation, resultData, mimeType); if (this.TestExecutionMode == "generate") { throw new NotImplementedException("The .net test runner does not support test update/generation. Please use the PHP test runner for this purpose"); /* //Get the sample result that is stored in the database. If we are using file on disk for validation //then do not overwrite the filename in the database //To distinguish between sample data and filename all filenames should be prefixed with "@@" int status = vm.Execute("Select Result from ApiTestResults where ParamSet={0}", paramSetId); string sampleResult = vm.GetString("Result"); if (!sampleResult.StartsWith("@@")) { //Insert the sample data as a BLOB //Update the row for that param set or create a new row if we do not have it yet string responseBody = ""; if (status == Sqlite.Row) { vm.Prepare("update ApiTestResults set Result = :blob where ParamSet={0}", paramSetId); } else { Console.WriteLine("A new row has been created in ApiTestResults table to store the result for operation {0}", paramSetId); Console.WriteLine("Please update the description field for that row later"); vm.Prepare("INSERT INTO ApiTestResults(ParamSet, Result) VALUES({0}, :blob)", paramSetId); } byte[] bytes = Encoding.UTF8.GetBytes(resultData); vm.BindBlob(":blob", bytes); vm.Execute(); if (mimeType != null) { vm.Execute("UPDATE ApiTestResults SET ContentType=\"{0}\" WHERE ParamSet={1}", mimeType, paramSetId); } File.WriteAllText(fileName, resultData); } */ } else if (this.TestExecutionMode == "validate" || this.TestExecutionMode == "show") { string resultContent = ""; //Get the sample result and the expected content type from the database int status = vm.Execute("Select Result, ContentType from ApiTestResults where ParamSet={0}", paramSetId); string expectedContentType = vm.GetString("ContentType"); string expectedExtension = CommonUtility.GetExtensionFromMimeType(expectedContentType); SqliteGcBlob blob = vm.GetBlob("Result"); byte[] b = blob.Read(); if (b != null) { if (expectedExtension == "xml" || expectedExtension == "txt" || expectedExtension == "html") expectedResult = Encoding.UTF8.GetString(b); else expectedResult = b; } else { if (expectedExtension == "xml" || expectedExtension == "txt" || expectedExtension == "html") expectedResult = string.Empty; else expectedResult = null; } string strExpectedResult = expectedResult as string; //If we are validating from a file then get the contents of that file //File names should be prefixed with "@@" to distinguish them from BLOB data if (strExpectedResult != null && strExpectedResult.StartsWith("@@")) { string sampleDataFile = strExpectedResult.Substring(2); sampleDataFile = CommonUtility.GetPath(sampleDataFile); expectedResult = File.ReadAllText(sampleDataFile); } if (this.TestExecutionMode == "validate") { bool bEqual = false; byte[] bExpected = expectedResult as byte[]; byte[] bActual = resultData as byte[]; string strResultData = resultData as string; //FIXME: We're not processing DWF content properly to do this check properly. So just //pass these for now if (operation == "GETDRAWINGLAYER" || operation == "GETDRAWINGSECTION") { bEqual = true; } else { if (strExpectedResult != null && strResultData != null) { bEqual = strResultData.Equals(strExpectedResult, StringComparison.InvariantCultureIgnoreCase); } else if (bExpected != null && bActual != null) { bEqual = CommonUtility.ByteArraysEqual(bExpected, bActual, operation, testName); } else { System.Diagnostics.Debug.WriteLine(string.Format("[MgTestRunner]: {0} - {1} - Encountered disparate data types between expected and actual results. Expecting test failure :(", testName, operation)); } } //If the results are different and special validation fails then the operation failed ->mark it red if (!bEqual && !CommonUtility.SpecialValidation(operation, resultData, expectedResult)) { outcome = "fail"; exitStatus = 1; if (expectedExtension != "xml" && expectedExtension != "html" && expectedExtension != "txt") { expectedResult = "Unable to display binary data"; } if (actualExtension != "xml" && actualExtension != "html" && actualExtension != "txt") { resultData = "Unable to display binary data"; } } } else { throw new NotImplementedException("The .net test runner does not support the given test execution mode (" + this.TestExecutionMode + "). Please use the PHP test runner for this purpose"); /* type = testName.Substring(testName.IndexOf("_") + 1); string showPath = CommonUtility.GetPath(string.Format("../../TestData/{0}/ShowFiles/{0}ApiTest", type)); string showName = string.Format("{0}_{1}.{2}", showPath, paramSetId, actualExtension); File.WriteAllText(showName, expectedResult); */ } } } } if (outcome == "fail") { Console.WriteLine("****{0} {1} {2} failed.\n", testName, paramSetId, operation); string str = string.Format("\n****ACTUAL RESULT****\n{0}\n****EXPECTED RESULT****\n{1}\n********\n\n\n", resultData, expectedResult); //Console.WriteLine(str); //Console.WriteLine("<FAIL>"); logger.Write(str); } vm.SqlFinalize(); vm = null; return exitStatus; }
public static bool HasLogger(this ITestLogger logger, ITestLogger childLogger) { return logger.HasLogger<ITestLogger>(l => l == childLogger); }
public FakeIOrganizationService(IOrganizationService service, ITestLogger logger) : base(service) { Timer = new TestActionTimer(logger); RedirectExecuteRequestsToOrganizationServiceRequest = true; }
public ITestRunner BuildRunner(ITestLogger logger) { return new GTestRunner(logger); }
public int Execute(ref int testsRun, ITestLogger logger, bool isEnterprise) { int exitStatus = 0; string dbPath = CommonUtility.GetDbPath(this.DumpFile); string dbName = CommonUtility.GetPath(dbPath); if (File.Exists(dbName)) { var db = new SqliteDb(); db.Open(dbName); var vm = new SqliteVm(db, true); int status = vm.Execute("Select TestName, TestType from TestCase where TestType=\"{0}\" order by ExecuteSequence", this.ApiType); //NOTE: We can't share the SqliteVm instance among our executor objects as this messes up query results //we must be able to re-create a new SqliteVm for each executor, so we pass down the db path SetupExecutors(dbName); while (status == Sqlite.Row) { string testName = vm.GetString("TestName"); string testType = vm.GetString("TestType"); Console.WriteLine("Executing {0} test: {1}", testType, testName); using (var run = new TestExecutionRun(dbPath, this)) { try { exitStatus += run.RunTests(testName, logger, ref testsRun); } catch (Exception ex) { Console.WriteLine(ex.ToString()); exitStatus += 1; } } status = vm.NextRow(); } vm.SqlFinalize(); vm = null; db = null; } return exitStatus; }
public TestServerLogger(ITestLogger logger, params string[] context) : base(logger, context) { }
public void RequestRun(ITestCase cCase, ITestLogger logger) { TestCount = cCase.Tests.Length; TestsCompleted = 0; TestsFailed = 0; TestsIgnored = 0; TestsPassed = 0; GTestRunner runner = new GTestRunner(logger); runner.TestCompleted += RunnerOnTestCompleted; runner.RunCompleted += RunnerOnRunCompleted; runner.Run(cCase); }
public void Test(ITestLogger logger) { Logger = logger; var timer = new TestActionTimer(logger); LoadConfigurationSettingsOnce(this); InitializeEntityIds(); if (EntityIds != null && EntityIds.Count > 0) { timer.Time(PopulateEntityReferences, "Initialization Entity Reference (ms): "); } using (var internalService = GetInternalOrganizationServiceProxy()) { // ReSharper disable once AccessToDisposedClosure timer.Time(() => CleanupTestData(internalService, false), "Cleanup PreTestData (ms): "); try { // ReSharper disable once AccessToDisposedClosure timer.Time(() => ValidateAssumptions(internalService), "Validate Assumptions (ms): "); var service = GetIOrganizationService(); AssertCrm = new AssertCrm(service); timer.Time(() => InitializeTestData(service), "Initialize TestData (ms): "); timer.Time(() => Test(service), "Run Test (ms): "); } finally { // ReSharper disable once AccessToDisposedClosure timer.Time(() => CleanupTestData(internalService, true), "Cleanup PostTestData (ms): "); } } }
public void SetUp() { _rootSuiteName = "C:\\Program Files\\NUnit 2.2.9\\bin\\mock-assembly.dll"; _passingTestName = "NUnit.Tests.Assemblies.MockTestFixture.MockTest1"; _logger = MockRepository.GenerateMock<IMessageLogger>(); _suiteLogger = MockRepository.GenerateMock<ITestSuiteMessageLogger>(); _testLogger = MockRepository.GenerateMock<ITestLogger>(); _logger.Stub(x => x.WriteTestSuiteStarted(Arg<string>.Is.Anything)).Return(_suiteLogger); _suiteLogger.Stub(x => x.WriteTestStarted(Arg<string>.Is.Anything)).Return(_testLogger); _subject = new NunitMessageProcessor(_logger); }
public KarmaServerTestLogger(ITestLogger logger) : base(logger) { }
public BaseFixture() { Logger = new TestKarmaLogger(message => Console.WriteLine("[{0:0.0}] {1}", Elapsed, message)); }
public ProjectListener([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider, ITestLogger logger) { ValidateArg.NotNull(serviceProvider, "serviceProvider"); _projectDocTracker = serviceProvider.GetService(typeof(SVsTrackProjectDocuments)) as IVsTrackProjectDocuments2; Logger = new TestLogger(logger, "ProjectListener"); }
public static void RemoveLogger(this ITestLogger logger, ITestLogger childLogger) { logger.RemoveLogger<ITestLogger>(l => l == childLogger); }
public void RequestRun(ITest test, ITestLogger logger) { TestCount = 1; TestsCompleted = 0; TestsFailed = 0; TestsIgnored = 0; TestsPassed = 0; GTestRunner runner = new GTestRunner(logger); runner.TestCompleted += RunnerOnTestCompleted; runner.RunCompleted += RunnerOnRunCompleted; runner.Run(test); }
public void Add(ITestLogger log) { children.Add(log); }
public void RequestRun(ITestSuite suite, ITestLogger logger) { int testCount = 0; foreach (var testCase in suite.TestCases) { testCount += testCase.Tests.Length; } TestCount = testCount; TestsCompleted = 0; TestsFailed = 0; TestsIgnored = 0; TestsPassed = 0; GTestRunner runner = new GTestRunner(logger); runner.TestCompleted += RunnerOnTestCompleted; runner.RunCompleted += RunnerOnRunCompleted; runner.Run(suite); }
private async Task<int> RunTests(TestSourceSettings settings, ITestLogger logger, IRunContext runContext, IFrameworkHandle frameworkHandle) { logger = new TestLogger(logger, settings.Name, "Run"); var count = 0; if (settings.Port > 0) { logger.Debug("Start"); var discoverCommand = new DiscoverCommand(settings.Port); await discoverCommand.Run(spec => { RunTest(settings, logger, runContext, frameworkHandle, spec); count += 1; }); logger.Debug("Complete: {0} tests", count); } else { logger.Error("Not connected to {0}", TestAdapterInfo.Name); } return count; }
public abstract int ValidateRequest(SqliteDb db, string testName, int paramSetId, string operation, TestResult actualResult, ITestLogger logger);
private void RunTest(TestSourceSettings settings, ITestLogger logger, IRunContext runContext, IFrameworkHandle frameworkHandle, Spec spec) { var testCase = CreateTestCase(settings, spec); var outcome = TestOutcome.None; frameworkHandle.RecordStart(testCase); foreach (var result in spec.Results) { if (result.Skipped && outcome != TestOutcome.Failed) { outcome = TestOutcome.Skipped; } if (result.Success && outcome == TestOutcome.None) { outcome = TestOutcome.Passed; } if (!result.Success && !result.Skipped) { outcome = TestOutcome.Failed; } frameworkHandle.RecordResult(GetResult(testCase, result, frameworkHandle)); } frameworkHandle.RecordEnd(testCase, outcome); }