public void Clone_Always_CreatesDeepClone()
{
IReadOnlyList <string> exclude = new[] { "a" };
IReadOnlyList <string> excludeFiles = new[] { "b" };
IReadOnlyList <string> include = new[] { "c" };
IReadOnlyList <string> includeFiles = new[] { "d" };
var expectedResult = new IncludeExcludeFiles()
{
Exclude = exclude,
ExcludeFiles = excludeFiles,
Include = include,
IncludeFiles = includeFiles
};
int expectedHashCode = expectedResult.GetHashCode();
IncludeExcludeFiles actualResult = expectedResult.Clone();
int actualHashCode = actualResult.GetHashCode();
Assert.NotSame(expectedResult, actualResult);
Assert.Equal(expectedResult, actualResult);
Assert.Equal(expectedHashCode, actualHashCode);
Assert.NotSame(expectedResult.Exclude, actualResult.Exclude);
Assert.Equal(exclude, actualResult.Exclude);
Assert.NotSame(expectedResult.ExcludeFiles, actualResult.ExcludeFiles);
Assert.Equal(excludeFiles, actualResult.ExcludeFiles);
Assert.NotSame(expectedResult.Include, actualResult.Include);
Assert.Equal(include, actualResult.Include);
Assert.NotSame(expectedResult.IncludeFiles, actualResult.IncludeFiles);
Assert.Equal(includeFiles, actualResult.IncludeFiles);
}
public void Equals_WithOther_ReturnsCorrectValue()
{
var files1 = new IncludeExcludeFiles();
var files2 = new IncludeExcludeFiles();
Assert.False(files1.Equals(other: null));
Assert.True(files1.Equals(other: files1));
Assert.True(files1.Equals(other: files2));
var files = new List <string>()
{
"a"
};
files1.Exclude = files;
Assert.False(files1.Equals(files2));
files2.Exclude = files;
Assert.True(files1.Equals(files2));
files1.ExcludeFiles = files;
Assert.False(files1.Equals(files2));
files2.ExcludeFiles = files;
Assert.True(files1.Equals(files2));
files1.Include = files;
Assert.False(files1.Equals(files2));
files2.Include = files;
Assert.True(files1.Equals(files2));
files1.IncludeFiles = files;
Assert.False(files1.Equals(files2));
files2.IncludeFiles = files;
Assert.True(files1.Equals(files2));
}
public void HandleIncludeExcludeFiles_WhenJsonObjectIsNull_Throws()
{
var files = new IncludeExcludeFiles();
ArgumentNullException exception = Assert.Throws <ArgumentNullException>(
() => files.HandleIncludeExcludeFiles(jsonObject: null));
Assert.Equal("jsonObject", exception.ParamName);
}
public void Constructor_Always_InitializesProperties()
{
var files = new IncludeExcludeFiles();
Assert.Null(files.Exclude);
Assert.Null(files.ExcludeFiles);
Assert.Null(files.Include);
Assert.Null(files.IncludeFiles);
}
public void HandleIncludeExcludeFiles_WithNullForFiles_ReturnsFalse(string json)
{
JObject jsonObject = JObject.Parse(json);
var files = new IncludeExcludeFiles();
Assert.False(files.HandleIncludeExcludeFiles(jsonObject));
Assert.Null(files.Exclude);
Assert.Null(files.ExcludeFiles);
Assert.Null(files.Include);
Assert.Null(files.IncludeFiles);
}
public void Equals_WithObj_ReturnsCorrectValue()
{
var files1 = new IncludeExcludeFiles();
var files2 = new IncludeExcludeFiles();
Assert.False(files1.Equals(obj: null));
Assert.False(files1.Equals(obj: "b"));
Assert.False(files1.Equals(obj: new object()));
Assert.True(files1.Equals(obj: files1));
Assert.True(files1.Equals(obj: files2));
}
public void HandleIncludeExcludeFiles_WithValidValueForInclude_ReturnsTrue(
string json,
params string[] expectedResults)
{
JObject jsonObject = JObject.Parse(json);
var files = new IncludeExcludeFiles();
Assert.True(files.HandleIncludeExcludeFiles(jsonObject));
Assert.Null(files.Exclude);
Assert.Null(files.ExcludeFiles);
Assert.Equal(expectedResults, files.Include);
Assert.Null(files.IncludeFiles);
}
public void IncludeExcludeFilesCloneTest()
{
//Set up
var exclude = new List <string>()
{
"Exlclude0"
};
var include = new List <string>()
{
"Include0"
};
var includeFiles = new List <string>()
{
"IncludeFiles0"
};
var excludeFiles = new List <string>()
{
"ExlcludeFiles0"
};
var files = new IncludeExcludeFiles();
files.Exclude = exclude;
files.Include = include;
files.IncludeFiles = includeFiles;
files.ExcludeFiles = excludeFiles;
// Act
var clone = files.Clone();
//Assert
Assert.Equal(files.Exclude, clone.Exclude);
Assert.Equal(files.Include, clone.Include);
Assert.Equal(files.IncludeFiles, clone.IncludeFiles);
Assert.Equal(files.ExcludeFiles, clone.ExcludeFiles);
// Act again
exclude.Add("Extra Exclude");
//Assert
Assert.Equal(2, files.Exclude.Count);
Assert.NotEqual(files.Exclude, clone.Exclude);
}
private static void CalculateExcludes(IncludeExcludeFiles files, out string fullExclude, out string filesExclude)
{
fullExclude = string.Empty;
filesExclude = string.Empty;
if (files.Exclude != null &&
files.Exclude.Any())
{
fullExclude = string.Join(";", files.Exclude);
}
if (files.ExcludeFiles != null &&
files.ExcludeFiles.Any())
{
if (!string.IsNullOrEmpty(fullExclude))
{
fullExclude += ";";
}
filesExclude += string.Join(";", files.ExcludeFiles);
fullExclude += filesExclude;
}
}
private IncludeExcludeFiles CreateIncludeExcludeFiles()
{
var files = new IncludeExcludeFiles();
files.Exclude = new List <string>()
{
"Exlclude0"
};
files.Include = new List <string>()
{
"Include0"
};
files.IncludeFiles = new List <string>()
{
"IncludeFiles0"
};
files.ExcludeFiles = new List <string>()
{
"ExlcludeFiles0"
};
return(files);
}
public void GetHashCode_Always_HashesAllProperties()
{
IReadOnlyList <string> exclude = new[] { "a" };
IReadOnlyList <string> excludeFiles = new[] { "b" };
IReadOnlyList <string> include = new[] { "c" };
IReadOnlyList <string> includeFiles = new[] { "d" };
int expectedResult = GetExpectedHashCode(exclude, excludeFiles, include, includeFiles);
var files = new IncludeExcludeFiles();
Assert.Equal(0, files.GetHashCode());
files.Exclude = exclude;
files.ExcludeFiles = excludeFiles;
files.Include = include;
files.IncludeFiles = includeFiles;
int actualResult = files.GetHashCode();
Assert.Equal(expectedResult, actualResult);
}
public void PackOptionsCloneTest()
{
//Set up
var originalPackOptions = new PackOptions();
var originalPackageName = "PackageA";
var packageTypes = new List <NuGet.Packaging.Core.PackageType>()
{
new Packaging.Core.PackageType(originalPackageName, new System.Version("1.0.0"))
};
var exclude = new List <string>()
{
"Exlclude0"
};
var include = new List <string>()
{
"Include0"
};
var includeFiles = new List <string>()
{
"IncludeFiles0"
};
var excludeFiles = new List <string>()
{
"ExlcludeFiles0"
};
var files = new IncludeExcludeFiles();
files.Exclude = exclude;
files.Include = include;
files.IncludeFiles = includeFiles;
files.ExcludeFiles = excludeFiles;
originalPackOptions.PackageType = packageTypes;
originalPackOptions.IncludeExcludeFiles = files;
// Act
var clone = originalPackOptions.Clone();
// Assert
Assert.Equal(originalPackOptions, clone);
// Act again
packageTypes.Clear();
// Assert
Assert.NotEqual(originalPackOptions, clone);
Assert.Equal(originalPackageName, clone.PackageType[0].Name);
// Set Up again
originalPackOptions.Mappings.Add("randomString", files);
// Act again
var cloneWithMappings = originalPackOptions.Clone();
// Assert
Assert.Equal(originalPackOptions, cloneWithMappings);
// Act again
originalPackOptions.Mappings.Clear();
// Assert
Assert.NotEqual(originalPackOptions, cloneWithMappings);
Assert.Equal(1, cloneWithMappings.Mappings.Count);
}
private bool ShouldInclude(string path)
{
return(ExcludeList
? !IncludeExcludeFiles.Contains(Path.GetFileName(path))
: IncludeExcludeFiles.Contains(Path.GetFileName(path)));
}
