public void CanReplaceEncryptedPasswordNotAtEndOfConnectionString()
{
const string connectionString = "Blah=Blah;ENCRYPTED_PASSWORD=abc;Bla=Bla";
Assert.AreEqual("Blah=Blah;ENCRYPTED_PASSWORD=****;Bla=Bla",
WorkspaceUtils.ReplacePassword(connectionString, "****"));
}
public void CanReplacePasswordAtWithoutPassword()
{
const string connectionString = "Blah=Blah;Bla=Bla";
Assert.AreEqual(connectionString,
WorkspaceUtils.ReplacePassword(connectionString, "****"));
}
public void CanReplacePasswordInvalidConnectionString()
{
const string connectionString = "Blah=Blah;Password";
Assert.AreEqual(connectionString,
WorkspaceUtils.ReplacePassword(connectionString, "****"));
}
public void CanReplacePasswordAtEndOfConnectionString()
{
const string connectionString = "Blah=Blah;Password=abc";
Assert.AreEqual("Blah=Blah;Password=****",
WorkspaceUtils.ReplacePassword(connectionString, "****"));
}
public void CanReplaceEmptyPassword()
{
const string connectionString = "Blah=Blah;Password=;";
Assert.AreEqual("Blah=Blah;Password=****;",
WorkspaceUtils.ReplacePassword(connectionString, "****"));
}
public void CanGetUnqualifiedVersionName()
{
string name =
WorkspaceUtils.GetUnqualifiedVersionName(@"""ESRI-DE\USERNAME"".MyVersion");
Assert.AreEqual("MyVersion", name);
}
public void CanReplacePasswordNotAtEndOfConnectionStringWithBlanks()
{
const string connectionString = "Blah = Blah ; Password = abc ; Bla = Bla";
Assert.AreEqual("Blah = Blah ; Password =****; Bla = Bla",
WorkspaceUtils.ReplacePassword(connectionString, "****"));
}
public async Task When_Building_From_Subject()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var compilation = await project.GetCompilationAsync();
var someClassTree = compilation.SyntaxTrees.Single(t => Path.GetFileName(t.FilePath) == "SomeClass.cs");
var rootNode = await someClassTree.GetRootAsync();
var model = compilation.GetSemanticModel(someClassTree);
var classSymbol = rootNode.GetAllDeclaredTypes(model).First();
Assert.AreEqual("SomeClass", classSymbol.Name);
var graph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var root = graph.GetNodeForType(classSymbol);
Assert.AreEqual(classSymbol.ToIdentifier(), root.Identifier);
Assert.AreEqual(4, root.ForwardLinks.Count);
AssertEx.Contains(root.ForwardLinkNodes, n => (n as TypeNode)?.Identifier.Name == "SomeEnumeratedClass");
AssertEx.Contains(root.ForwardLinkNodes, n => (n as TypeNode)?.Identifier.Name == "SomeClassCore");
var someOtherClassNode = AssertEx.Contains(root.ForwardLinkNodes, n => (n as TypeNode)?.Identifier.Name == "SomeOtherClass") as TypeNode;
CollectionAssert.Contains(someOtherClassNode.BackLinkNodes, root);
AssertEx.Contains(someOtherClassNode.BackLinkNodes, n => (n as TypeNode)?.Identifier.Name == "SomeCircularClass");
AssertEx.Contains(someOtherClassNode.ForwardLinkNodes, n => (n as TypeNode)?.Identifier.Name == "SomeClassInArray");
AssertEx.Contains(someOtherClassNode.ForwardLinkNodes, n => (n as TypeNode)?.Identifier.Name == "SomeDeeperClass");
AssertConsistentState(graph);
}
}
public static string GetDateLiteral(DateTime dateTime,
[NotNull] IWorkspace workspace)
{
Assert.ArgumentNotNull(workspace, nameof(workspace));
switch (workspace.Type)
{
case esriWorkspaceType.esriLocalDatabaseWorkspace:
if (WorkspaceUtils.IsFileGeodatabase(workspace))
{
return(GetFGDBDateLiteral(dateTime));
}
if (WorkspaceUtils.IsPersonalGeodatabase(workspace))
{
return(GetPGDBDateLiteral(dateTime));
}
throw new ArgumentOutOfRangeException(
string.Format("Unsupported local database workspace type: {0}",
workspace.PathName));
case esriWorkspaceType.esriRemoteDatabaseWorkspace:
var connectionInfo = (IDatabaseConnectionInfo2)workspace;
return(GetDateLiteral(dateTime, connectionInfo.ConnectionDBMS));
default:
throw new ArgumentOutOfRangeException(
string.Format("Unsupported workspace type: {0}", workspace.Type));
}
}
public async Task When_Two_Roots()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var graph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var someClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeClass")];
var someCircularClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeCircularClass")];
var roots = new HashSet <Node>();
roots.Add(someClassNode);
roots.Add(someCircularClassNode);
var paths = NodeGraphExtensions.GetMultiDependencyRootPaths(graph, roots).ToArray();
var path = paths.Single();
Assert.AreEqual(someClassNode, path.Source);
Assert.AreEqual(someCircularClassNode, path.Target);
Assert.AreEqual(2, path.Intermediates.Count);
Assert.AreEqual("SomeOtherClass", (path.Intermediates[0] as TypeNode).Identifier.Name);
Assert.AreEqual("SomeDeeperClass", (path.Intermediates[1] as TypeNode).Identifier.Name);
}
}
public async Task When_Root_With_BackLinks()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var compilation = await project.GetCompilationAsync();
var someClassTree = compilation.SyntaxTrees.Single(t => Path.GetFileName(t.FilePath) == "SomeOtherClass.cs");
var rootNode = await someClassTree.GetRootAsync();
var model = compilation.GetSemanticModel(someClassTree);
var classSymbol = rootNode.GetAllDeclaredTypes(model).First();
Assert.AreEqual("SomeOtherClass", classSymbol.Name);
var graph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var root = graph.GetNodeForType(classSymbol);
Assert.AreEqual(classSymbol.ToIdentifier(), root.Identifier);
Assert.AreEqual(3, root.ForwardLinks.Count);
Assert.AreEqual(2, root.BackLinks.Count);
AssertConsistentState(graph);
}
}
private static IList <QaError> GetErrors([NotNull] string tableName,
int maximumLength)
{
var locator = TestDataUtils.GetTestDataLocator();
string path = locator.GetPath("QaSchemaTests.mdb");
IFeatureWorkspace workspace = WorkspaceUtils.OpenPgdbFeatureWorkspace(path);
const int minimumValueCount = 1;
const int minimumNonEqualNameValueCount = 1;
const bool allowEmptyName = false;
ITable table = workspace.OpenTable(tableName);
var test = new QaSchemaFieldDomainCodedValues(table, maximumLength,
UniqueStringsConstraint.UniqueAnyCase,
minimumValueCount,
minimumNonEqualNameValueCount,
allowEmptyName);
var runner = new QaTestRunner(test);
runner.Execute();
return(runner.Errors);
}
public async Task When_Implemented_Interface()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var fullGraph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var implementingClassNode = fullGraph.Nodes.Values.Single(n => (n as TypeNode)?.Identifier.Name == "SomeBaseClass");
AssertImplements(implementingClassNode, "ISomeInheritedInterface");
AssertImplements(implementingClassNode, "ISomeStillOtherInterface");
AssertImplements(implementingClassNode, "ISomeGenericInterface<T>");
void AssertImplements(Node implementer, string interfaceName)
{
var interfaceLink = AssertEx.ContainsSingle(implementer.ForwardLinks, l => (l.Dependency as TypeNode)?.Identifier.Name == interfaceName);
Assert.AreEqual(LinkType.ImplementsInterface, interfaceLink.LinkType);
}
;
//var baseClassLink = AssertEx.ContainsSingle(inheritedClassNode.ForwardLinks, l => (l.Dependency as TypeNode)?.Identifier.Name == "SomeBaseClass");
//Assert.AreEqual(LinkType.InheritsFromClass, baseClassLink.LinkType);
//var derivedClassLink = AssertEx.ContainsSingle(inheritedClassNode.BackLinks, l => (l.Dependent as TypeNode)?.Identifier.Name == "SomeInheritedClassDepth2");
//Assert.AreEqual(LinkType.InheritsFromClass, baseClassLink.LinkType);
}
}
public void LearningTestSQLSyntaxPGDB()
{
IWorkspace workspace =
WorkspaceUtils.OpenPgdbWorkspace(TestData.GetGdb1Path());
LogSqlSyntax(workspace);
}
private static IDictionary <AttributeRole, string> GetFieldNames(
[NotNull] IFeatureWorkspace featureWorkspace)
{
var workspace = (IWorkspace)featureWorkspace;
if (WorkspaceUtils.IsFileGeodatabase(workspace))
{
return(new Dictionary <AttributeRole, string>
{
{ AttributeRole.Description, "Description" },
{ AttributeRole.FeatureSource, "DataSource" },
{ AttributeRole.WhereClause, "WhereClause" },
{ AttributeRole.BufferDistance, "BufferDistance" },
{ AttributeRole.GeneralizationTolerance, "GeneralizationTolerance" }
});
}
if (WorkspaceUtils.IsShapefileWorkspace(workspace))
{
return(new Dictionary <AttributeRole, string>
{
{ AttributeRole.Description, "Descript" },
{ AttributeRole.FeatureSource, "DataSource" },
{ AttributeRole.WhereClause, "Where" },
{ AttributeRole.BufferDistance, "BufferDist" },
{ AttributeRole.GeneralizationTolerance, "GeneralTol" }
});
}
throw new ArgumentException(
string.Format(
"Unsupported workspace for writing area of interest feature class: {0}",
WorkspaceUtils.GetConnectionString(workspace, true)));
}
public void CanHandleZeroLengthEndSegments()
{
const string featureClassName = "TLM_STEHENDES_GEWAESSER";
var locator = TestDataUtils.GetTestDataLocator();
string path = locator.GetPath("QaBorderSense.gdb");
IFeatureWorkspace workspace = WorkspaceUtils.OpenFileGdbFeatureWorkspace(path);
IFeatureClass featureClass = workspace.OpenFeatureClass(featureClassName);
// expect counter-clockwise: 0 errors
var runnerCounterClockwise = new QaContainerTestRunner(1000,
new QaBorderSense(
featureClass, false));
Assert.AreEqual(0, runnerCounterClockwise.Execute());
// expect clockwise: 1 error
var runnerClockwise = new QaContainerTestRunner(1000,
new QaBorderSense(featureClass,
true));
Assert.AreEqual(1, runnerClockwise.Execute());
}
public static IEnumerable <IObjectClass> GetIssueObjectClasses(
[NotNull] IFeatureWorkspace issueRepositoryWorkspace)
{
Assert.ArgumentNotNull(issueRepositoryWorkspace, nameof(issueRepositoryWorkspace));
foreach (string objectClassName in IssueDatasetUtils.ObjectClassNames)
{
IObjectClass objectClass;
try
{
objectClass = DatasetUtils.OpenObjectClass(issueRepositoryWorkspace,
objectClassName);
}
catch (COMException e)
{
_msg.DebugFormat("Unable to open object class {0} from {1}: {2}",
objectClassName,
WorkspaceUtils.GetWorkspaceDisplayText(
(IWorkspace)issueRepositoryWorkspace),
e.Message);
continue;
}
yield return(objectClass);
}
}
public void CanOpenFromConnectionString()
{
string catalogPath = GetWorkspaceCatalogPath();
IWorkspace workspace;
try
{
workspace = WorkspaceUtils.OpenPgdbWorkspace(catalogPath);
}
catch (Exception)
{
// TODO: Move test data to different format
if (EnvironmentUtils.Is64BitProcess)
{
Console.WriteLine("Expected exception: PGDB is not supported on x64");
return;
}
throw;
}
string connectionString = WorkspaceUtils.GetConnectionString(workspace);
var dataSource = new DataSource("test", "test")
{
WorkspaceAsText = connectionString
};
IWorkspace openedWorkspace = dataSource.OpenWorkspace();
Assert.IsNotNull(openedWorkspace);
Assert.AreEqual(workspace, openedWorkspace);
}
public static IWorkspace OpenOsaWorkspaceOracle([NotNull] string repositoryName = "SDE")
{
IWorkspace workspace = WorkspaceUtils.OpenSDEWorkspace(
repositoryName, DirectConnectDriver.Oracle11g, OracleDbNameSde);
return(workspace);
}
public static IWorkspace OpenPgdb(string testDataPath)
{
string fullPath = GetFullPath(testDataPath);
IWorkspace ws = WorkspaceUtils.OpenPgdbWorkspace(fullPath);
return(ws);
}
public async Task When_MultiDependency_Edge()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var graph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var someClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeClass")];
var deepClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeClassDepth5")];
var roots = new HashSet <Node>();
roots.Add(someClassNode);
roots.Add(deepClassNode);
var paths = NodeGraphExtensions.GetMultiDependencyRootPaths(graph, roots).ToArray();
var path = paths.Single();
var displayGraph = graph.GetDisplaySubgraph(subgraphNodes: roots, pinnedNodes: SetUtils.GetEmpty <NodeKey>());
var multiEdges = displayGraph.Edges.OfType <MultiDependencyDisplayEdge>();
AssertEx.ContainsSingle(multiEdges, m => m.Source.DisplayString.EndsWith("SomeClass") && m.Target.DisplayString.EndsWith("SomeClassDepth5"));
}
}
public void LearningTestSQLSyntaxFGDB()
{
IWorkspace workspace =
WorkspaceUtils.OpenFileGdbWorkspace(TestData.GetGdbTableJointUtilsPath());
LogSqlSyntax(workspace);
}
public async Task When_Display_Graph_Two_Roots_No_Extension()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var compilation = await project.GetCompilationAsync();
var someClassTree = compilation.SyntaxTrees.Single(t => Path.GetFileName(t.FilePath) == "SomeClass.cs");
var someCircularClassTree = compilation.SyntaxTrees.Single(t => Path.GetFileName(t.FilePath) == "SomeCircularClass.cs");
var roots =
new[] {
(await someClassTree.GetRootAsync()).GetAllDeclaredTypes(compilation.GetSemanticModel(someClassTree)).First(),
(await someCircularClassTree.GetRootAsync()).GetAllDeclaredTypes(compilation.GetSemanticModel(someCircularClassTree)).First()
};
var fullGraph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution),
ct : default);
var displayGraph = fullGraph.GetDisplaySubgraph(roots);
Assert.AreEqual(2, displayGraph.VertexCount);
var simpleEdges = displayGraph.Edges.OfType <SimpleDisplayEdge>().ToArray();
var multiEdges = displayGraph.Edges.OfType <MultiDependencyDisplayEdge>().ToArray();
Assert.AreEqual(0, simpleEdges.Length);
Assert.AreEqual(1, multiEdges.Length);
}
}
private static IIssueTableFields GetTargetFields(
[NotNull] ICollection <IObjectClass> targetExceptionClasses,
bool ensureRequiredFields = true)
{
IWorkspace workspace =
Assert.NotNull(DatasetUtils.GetUniqueWorkspace(targetExceptionClasses));
IIssueTableFieldManagement fields =
IssueTableFieldsFactory.GetIssueTableFields(
addExceptionFields: true,
useDbfFieldNames: WorkspaceUtils.IsShapefileWorkspace(workspace),
addManagedExceptionFields: true);
if (ensureRequiredFields)
{
using (_msg.IncrementIndentation("Ensuring required target fields"))
{
int addedFields = EnsureTargetFields(targetExceptionClasses, fields);
if (addedFields == 0)
{
_msg.Info("All required fields exist in target datasets");
}
}
}
return(fields);
}
public void CanSortByStringField()
{
IFeatureWorkspace featureWs =
WorkspaceUtils.OpenFileGdbFeatureWorkspace(TestData.GetArealeFileGdbPath());
ITable table = DatasetUtils.OpenTable(featureWs, "TLM_NUTZUNGSAREAL");
const string operatorFieldName = "OPERATEUR";
ICursor cursor = TableSortUtils.GetSortedTableCursor(table, operatorFieldName);
int fieldIndex = cursor.FindField(operatorFieldName);
Assert.True(fieldIndex >= 0, "Field not found");
string lastValue = null;
IRow row;
while ((row = cursor.NextRow()) != null)
{
object value = row.get_Value(fieldIndex);
Assert.False(value == DBNull.Value, "Empty field");
var currentValue = (string)value;
Console.WriteLine(currentValue);
if (lastValue != null)
{
Assert.False(currentValue.CompareTo(lastValue) < 0, "Not sorted");
}
lastValue = currentValue;
}
}
public void TableSortOnFgdbGuidsPerformance()
{
IFeatureWorkspace featureWs =
WorkspaceUtils.OpenFileGdbFeatureWorkspace(TestData.GetArealeFileGdbPath());
//IFeatureWorkspace featureWs = OpenTestWorkspace();
ITable table = DatasetUtils.OpenTable(featureWs, "TLM_NUTZUNGSAREAL");
//ITable table = DatasetUtils.OpenTable(featureWs, "TOPGIS_TLM.TLM_NUTZUNGSAREAL");
const string uuidFieldName = "UUID";
var watch = new Stopwatch();
watch.Start();
ICursor cursor = TableSortUtils.GetSortedTableCursor(table, uuidFieldName);
LoopAndWrite(cursor, uuidFieldName);
watch.Stop();
long standardSort = watch.ElapsedMilliseconds;
//featureWs = OpenTestWorkspace();
//table = DatasetUtils.OpenTable(featureWs, "TOPGIS_TLM.TLM_NUTZUNGSAREAL");
watch = new Stopwatch();
watch.Start();
cursor = TableSortUtils.GetGuidFieldSortedCursor(table, uuidFieldName);
LoopAndWrite(cursor, uuidFieldName);
watch.Stop();
Console.WriteLine(@"Standard Sorter: {0}", standardSort);
Console.WriteLine(@"Guid Sorter: {0}", watch.ElapsedMilliseconds);
}
public static IWorkspace OpenDDxWorkspaceOracle()
{
IWorkspace workspace = WorkspaceUtils.OpenSDEWorkspace(
"SDE", DirectConnectDriver.Oracle11g, OracleDbNameDdx,
"unittest", "unittest");
return(workspace);
}
public static IWorkspace OpenSDEWorkspaceOracle()
{
IWorkspace workspace = WorkspaceUtils.OpenSDEWorkspace(
"SDE", DirectConnectDriver.Oracle11g, OracleDbNameSde,
"sde", "sde");
return(workspace);
}
public void CanGetWorkspaceDisplayTextForOracle()
{
IWorkspace workspace = TestUtils.OpenUserWorkspaceOracle();
string text = WorkspaceUtils.GetWorkspaceDisplayText(workspace);
Console.WriteLine(text);
}
public void TestGetCodedValues()
{
IWorkspace workspace = WorkspaceUtils.OpenPgdbWorkspace(_simpleGdbPath);
SortedDictionary <int, string> list = DomainUtils.GetCodedValueMap <int>(
workspace, "TestCodedValueDomain");
Assert.AreEqual(5, list.Count);
Assert.AreEqual("Value7", list[7]);
}
