<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>bin\Debug\hmlib.XML</DocumentationFile>
+ <RunCodeAnalysis>false</RunCodeAnalysis>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
</ItemGroup>
<ItemGroup />
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
- <Import Project="$(ProgramFiles)\MSBuild\Microsoft\StyleCop\v4.4\Microsoft.StyleCop.Targets" />
+ <Import Project="$(ProgramFiles)\MSBuild\StyleCop\v4.7\StyleCop.Targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
{
// 入力値確認
result = null;
- if (String.IsNullOrEmpty(s) || !s.StartsWith(XmlCommentElement.DelimiterStart))
+ if (string.IsNullOrEmpty(s) || !s.StartsWith(XmlCommentElement.DelimiterStart))
{
return false;
}
{
this.Name = name;
this.Attributes = new Dictionary<string, string>();
- if (!String.IsNullOrEmpty(value))
+ if (!string.IsNullOrEmpty(value))
{
this.Add(new TextElement(value));
}
{
// 入力値確認。タグでない場合は即終了
result = null;
- if (String.IsNullOrEmpty(s) || s[0] != '<')
+ if (string.IsNullOrEmpty(s) || s[0] != '<')
{
return false;
}
/// </remarks>
private bool ValidateName(string name)
{
- if (String.IsNullOrWhiteSpace(name))
+ if (string.IsNullOrWhiteSpace(name))
{
return false;
}
// 属性名を確認
// ※ 属性が無い場合0文字となる
key = s.Substring(i, index - i);
- if (!String.IsNullOrEmpty(key) && !this.ValidateName(key))
+ if (!string.IsNullOrEmpty(key) && !this.ValidateName(key))
{
// 属性名の位置に出現し得ない記号が含まれているなど構文エラーも弾く
return false;
else if (c == '>' || c == '/')
{
// ループ終了
- if (!String.IsNullOrEmpty(key))
+ if (!string.IsNullOrEmpty(key))
{
// 属性名だけで値が無いパターン（<div disable>とか）
- a[this.parser.Decode(key)] = String.Empty;
+ a[this.parser.Decode(key)] = string.Empty;
key = null;
}
{
// 既にスペースが出現した状態で新たに普通の文字が出現した場合、
// キーだけで値が無いパターンだったと判定
- a[this.parser.Decode(key)] = String.Empty;
+ a[this.parser.Decode(key)] = string.Empty;
key = null;
existedSpace = false;
}
{
if (s == null)
{
- return String.Empty;
+ return string.Empty;
}
else if (this.IsHtml)
{
// すべての値を指定するか、下のように '*' を使ってビルドおよびリビジョン番号を
// 既定値にすることができます:
// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.3.*")]
+[assembly: AssemblyVersion("0.4.*")]
// 本ライブラリをC#以外の言語からも利用可能となるよう共通言語仕様準拠とする
[assembly: System.CLSCompliant(true)]
/// <returns>渡されたオブジェクトを<c>ToString</c>した結果。<c>null</c>の場合には空の文字列。</returns>
public static string ToString(object obj)
{
- return ObjectUtils.ToString(obj, String.Empty);
+ return ObjectUtils.ToString(obj, string.Empty);
}
/// <summary>
/// <returns>渡された文字列、<c>null</c>の場合には空の文字列。</returns>
public static string DefaultString(string str)
{
- return StringUtils.DefaultString(str, String.Empty);
+ return StringUtils.DefaultString(str, string.Empty);
}
/// <summary>
/// <returns>開始位置からの部分文字列。</returns>
public static string Substring(string str, int startIndex)
{
- return StringUtils.Substring(str, startIndex, Int32.MaxValue);
+ return StringUtils.Substring(str, startIndex, int.MaxValue);
}
/// <summary>
int i = startIndex > 0 ? startIndex : 0;
if (i > str.Length)
{
- return String.Empty;
+ return string.Empty;
}
int l = length > 0 ? length : 0;
(Match match)
=>
{
- int index = Int32.Parse(match.Groups[1].Value) - 1;
- return args.Length > index ? ObjectUtils.ToString(args[index]) : String.Empty;
+ int index = int.Parse(match.Groups[1].Value) - 1;
+ return args.Length > index ? ObjectUtils.ToString(args[index]) : string.Empty;
});
}
}
// 次に空文字列の判定（nullと空文字列は一応区別）
- if (String.IsNullOrEmpty(strA) && String.IsNullOrEmpty(strB))
+ if (string.IsNullOrEmpty(strA) && string.IsNullOrEmpty(strB))
{
return 0;
}
- else if (String.IsNullOrEmpty(strA))
+ else if (string.IsNullOrEmpty(strA))
{
return 1;
}
- else if (String.IsNullOrEmpty(strB))
+ else if (string.IsNullOrEmpty(strB))
{
return -1;
}
// どちらもnull or 空で無い場合は普通に判定
- return String.Compare(strA, strB);
+ return string.Compare(strA, strB);
}
#endregion
/// <exception cref="ArgumentException">文字列が長さ0。</exception>
public static string NotEmpty(string str, string paramName = "value")
{
- if (NotNull(str, paramName) == String.Empty)
+ if (NotNull(str, paramName) == string.Empty)
{
throw new ArgumentException("The validated string is empty", paramName);
}
/// <exception cref="ArgumentException">文字列が空か空白のみ。</exception>
public static string NotBlank(string str, string paramName = "value")
{
- if (String.IsNullOrWhiteSpace(NotNull(str, paramName)))
+ if (string.IsNullOrWhiteSpace(NotNull(str, paramName)))
{
throw new ArgumentException("The validated string is blank", paramName);
}
/// <returns>渡されたノードを<see cref="XmlNode.InnerText"/>した結果。<c>null</c>の場合には空の文字列。</returns>
public static string InnerText(XmlNode node)
{
- return XmlUtils.InnerText(node, String.Empty);
+ return XmlUtils.InnerText(node, string.Empty);
}
/// <summary>
/// <returns>渡されたノードを<see cref="XmlNode.InnerXml"/>した結果。<c>null</c>の場合には空の文字列。</returns>
public static string InnerXml(XmlNode node)
{
- return XmlUtils.InnerXml(node, String.Empty);
+ return XmlUtils.InnerXml(node, string.Empty);
}
/// <summary>
/// <returns>渡されたノードを<see cref="XmlNode.OuterXml"/>した結果。<c>null</c>の場合には空の文字列。</returns>
public static string OuterXml(XmlNode node)
{
- return XmlUtils.OuterXml(node, String.Empty);
+ return XmlUtils.OuterXml(node, string.Empty);
}
/// <summary>
<AssemblyName>HmLibTest</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
- <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+ <TargetFrameworkProfile>
+ </TargetFrameworkProfile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
- <StartAction>Program</StartAction>
- <StartProgram>$(ProgramFiles)\NUnit 2.5.5\bin\net-2.0\nunit.exe</StartProgram>
<DocumentationFile>bin\Debug\HmLibTest.XML</DocumentationFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
- <Reference Include="nunit.framework, Version=2.5.5.10112, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
+ <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="System" />
<Reference Include="System.XML" />
</ItemGroup>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
- <Import Project="$(ProgramFiles)\MSBuild\Microsoft\StyleCop\v4.4\Microsoft.StyleCop.Targets" />
+ <Import Project="$(ProgramFiles)\MSBuild\StyleCop\v4.7\StyleCop.Targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
{
using System;
using System.Collections.Generic;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// IgnoreCaseDictionaryのテストクラスです。
+ /// <see cref="IgnoreCaseDictionary<TValue>"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class IgnoreCaseDictionaryTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース（引数なし）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
IgnoreCaseDictionary<string> d = new IgnoreCaseDictionary<string>();
/// <summary>
/// コンストラクタテストケース（引数Dictionary）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorDictionary()
{
IDictionary<string, string> inner = new Dictionary<string, string>();
/// <summary>
/// コンストラクタテストケース（引数Dictionary、null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorDictionaryNull()
{
/// <summary>
/// Dictionaryプロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestDictionary()
{
IgnoreCaseDictionary<string> d = new IgnoreCaseDictionary<string>();
/// <summary>
/// Dictionaryプロパティテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestDictionaryNull()
{
/// <summary>
/// Keysプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestKeys()
{
// ラップするIDictionaryと同じ値であること
/// <summary>
/// Valuesプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestValues()
{
// ラップするIDictionaryと同じ値であること
/// <summary>
/// Countプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCount()
{
// ラップするIDictionaryと同じ値であること
/// <summary>
/// IsReadOnlyプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsReadOnly()
{
// ラップするIDictionaryと同じ値であること
/// <summary>
/// thisインデクサーテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestThis()
{
IgnoreCaseDictionary<string> d = new IgnoreCaseDictionary<string>();
/// <summary>
/// thisインデクサーテストケース（get、null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestThisGetNull()
{
/// <summary>
/// thisインデクサーテストケース（set、null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestThisSetNull()
{
/// <summary>
/// thisインデクサーテストケース（get、値なし）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(KeyNotFoundException))]
public void TestThisKeyNotFound()
{
/// <summary>
/// Addメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAdd()
{
// IDictionaryのAddメソッド
/// <summary>
/// Addメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestAddNull()
{
/// <summary>
/// Addメソッドテストケース（KeyValuePairのKeyがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestAddKeyNull()
{
/// <summary>
/// Addメソッドテストケース（重複）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestAddDuplicate()
{
/// <summary>
/// Addメソッドテストケース（KeyValuePairのKeyが重複）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestAddKeyDuplicate()
{
/// <summary>
/// ContainsKeyメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestContainsKey()
{
IgnoreCaseDictionary<string> d = new IgnoreCaseDictionary<string>();
/// <summary>
/// ContainsKeyメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestContainsKeyNull()
{
/// <summary>
/// Removeメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestRemove()
{
// IDictionaryのRemoveメソッド
/// <summary>
/// Removeメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestRemoveNull()
{
/// <summary>
/// TryGetValueメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryGetValue()
{
IgnoreCaseDictionary<string> d = new IgnoreCaseDictionary<string>();
/// <summary>
/// TryGetValueメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestTryGetValueNull()
{
/// <summary>
/// Clearメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestClear()
{
// 全データが削除されること、またラップしているオブジェクトは維持されること
/// <summary>
/// Containsメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestContains()
{
IgnoreCaseDictionary<string> d = new IgnoreCaseDictionary<string>();
/// <summary>
/// CopyToメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCopyTo()
{
IgnoreCaseDictionary<string> d = new IgnoreCaseDictionary<string>();
/// <summary>
/// CopyToメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestCopyToNull()
{
/// <summary>
/// CopyToメソッドテストケース（インデックスがマイナス値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void TestCopyToOutOfRange()
{
/// <summary>
/// CopyToメソッドテストケース（領域不足）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestCopyToOverflow()
{
/// <summary>
/// GetEnumeratorメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetEnumerator()
{
// ラップするIDictionaryと同じ値であること
{
using System;
using System.Collections.Generic;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// IgnoreCaseSetのテストクラスです。
+ /// <see cref="IgnoreCaseSet"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class IgnoreCaseSetTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース（引数なし）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// コンストラクタテストケース（引数Set）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorSet()
{
ISet<string> inner = new HashSet<string>();
/// <summary>
/// コンストラクタテストケース（引数Enumerable）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorEnumerable()
{
IList<string> other = new List<string>();
/// <summary>
/// コンストラクタテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorSetNull()
{
/// <summary>
/// Setプロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestSet()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// Setプロパティテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestSetNull()
{
/// <summary>
/// Countプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCount()
{
// ラップするISetと同じ値であること
/// <summary>
/// IsReadOnlyプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsReadOnly()
{
// ラップするISetと同じ値であること
/// <summary>
/// Addメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAdd()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// Addメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestAddNull()
{
/// <summary>
/// Containsメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestContains()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// Containsメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestContainsNull()
{
/// <summary>
/// Clearメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestClear()
{
// 全データが削除されること、またラップしているオブジェクトは維持されること
/// <summary>
/// CopyToメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCopyTo()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// CopyToメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestCopyToNull()
{
/// <summary>
/// CopyToメソッドテストケース（インデックスがマイナス値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void TestCopyToOutOfRange()
{
/// <summary>
/// CopyToメソッドテストケース（領域不足）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestCopyToOverflow()
{
/// <summary>
/// ExceptWithメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestExceptWith()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// ExceptWithメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestExceptWithNull()
{
/// <summary>
/// IntersectWithメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIntersectWith()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// IntersectWithメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestIntersectWithNull()
{
/// <summary>
/// IsProperSubsetOfメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsProperSubsetOf()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// IsProperSubsetOfメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestIsProperSubsetOfNull()
{
/// <summary>
/// IsProperSupersetOfメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsProperSupersetOf()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// IsProperSupersetOfメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestIsProperSupersetOfNull()
{
/// <summary>
/// IsSubsetOfメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsSubsetOf()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// IsSubsetOfメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestIsSubsetOfNull()
{
/// <summary>
/// IsSupersetOfメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsSupersetOf()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// IsSupersetOfメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestIsSupersetOfNull()
{
/// <summary>
/// Overlapsメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestOverlaps()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// Overlapsメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestOverlapsNull()
{
/// <summary>
/// Removeメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestRemove()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// Removeメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestRemoveNull()
{
/// <summary>
/// SetEqualsメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestSetEquals()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// SetEqualsメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestSetEqualsNull()
{
/// <summary>
/// SymmetricExceptWithメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestSymmetricExceptWith()
{
IgnoreCaseSet set = new IgnoreCaseSet();
/// <summary>
/// SymmetricExceptWithメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestSymmetricExceptWithNull()
{
/// <summary>
/// UnionWithメソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestUnionWith()
{
// 両方の値が格納される、重複するものは後の値で上書き
/// <summary>
/// UnionWithメソッドテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestUnionWithNull()
{
/// <summary>
/// GetEnumeratorメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetEnumerator()
{
// ラップするISetと同じ値であること
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MemoryCacheTest
{
#region プロパティテストケース
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Capacity"/>プロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCapacity()
{
MemoryCache<string, string> cache = new MemoryCache<string, string>();
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Capacity"/>プロパティテストケース（0以下の値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestCapacityZero()
{
/// <summary>
/// インデクサーテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestThis()
{
// ※ 以下古いほうから削除の確認のために、登録時に毎回ウェイトを入れる
/// <summary>
/// インデクサーテストケース（getでnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestThisGetNull()
{
/// <summary>
/// インデクサーテストケース（getで値無し）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(KeyNotFoundException))]
public void TestThisGetEmpty()
{
/// <summary>
/// インデクサーテストケース（setでnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestThisSetNull()
{
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Add"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAdd()
{
// ※ 2012年2月現在、重複チェック以外はインデクサーと同じなので割愛
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Add"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestAddNull()
{
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Add"/>メソッドテストケース（重複）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestAddAlready()
{
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.ContainsKey"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestContainsKey()
{
MemoryCache<string, string> cache = new MemoryCache<string, string>();
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.ContainsKey"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestContainsKeyNull()
{
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Remove"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestRemove()
{
// 指定されたキャッシュが削除される
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Remove"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestRemoveNull()
{
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.TryGetValue"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryGetValue()
{
// ※ 2012年2月現在、例外処理以外についてはインデクサーやGetと同じなので割愛
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.TryGetValue"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestTryGetValueNull()
{
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Clear"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestClear()
{
// 全てのキャッシュが削除される
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Get"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGet()
{
// ※ 2012年2月現在インデクサーを呼んでいるだけなのでテスト割愛
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Get"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestGetNull()
{
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.Get"/>メソッドテストケース（値無し）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(KeyNotFoundException))]
public void TestGetEmpty()
{
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.GetAndAddIfEmpty"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetAndAddIfEmpty()
{
MemoryCache<string, string> cache = new MemoryCache<string, string>();
/// <summary>
/// <see cref="MemoryCache<TKey, TValue>.GetAndAddIfEmpty"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestGetAndAddIfEmptyNull()
{
/// <summary>
/// 全体のテストケース（並列実行）。
/// </summary>
- [Test, Timeout(1500)]
+ [TestMethod, Timeout(1500)]
public void TestMemoryCacheParallel()
{
// 並列実行でいくつかのメソッドを呼んで問題ないかを確認する
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="AbstractElement"/>のテストクラスです。
/// </summary>
/// <remarks>テストには最小実装の<see cref="TextElement"/>を使用。</remarks>
- [TestFixture]
+ [TestClass]
internal class AbstractElementTest
{
#region インタフェース実装プロパティテストケース
/// <summary>
/// <see cref="AbstractElement.ParsedString"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestParsedString()
{
// 値が普通に設定できること
/// <summary>
/// <see cref="AbstractElement.ToString"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
// ParsedStringが設定されている場合その値が返ること
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="AbstractParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class AbstractParserTest
{
#region インタフェース実装メソッドテストケース
/// <summary>
/// <see cref="AbstractParser.Parse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestParse()
{
// TryParseを呼んだ結果が返ること
TestParser parser = new TestParser();
parser.Success = true;
- Assert.AreEqual(String.Empty, parser.Parse(String.Empty).ToString());
+ Assert.AreEqual(string.Empty, parser.Parse(string.Empty).ToString());
Assert.AreEqual("test", parser.Parse("test").ToString());
}
/// <summary>
/// <see cref="AbstractParser.Parse"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestParseNull()
{
/// <summary>
/// <see cref="AbstractParser.Parse"/>メソッドテストケース（解析失敗）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(FormatException))]
public void TestParseFail()
{
// TryParseがfalseを返した場合、例外を投げる
TestParser parser = new TestParser();
parser.Success = false;
- parser.Parse(String.Empty);
+ parser.Parse(string.Empty);
}
/// <summary>
/// <see cref="AbstractParser.IsPossibleParse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsPossibleParse()
{
// このクラスでは何を渡してもtrueが返る
/// <summary>
/// <see cref="AbstractParser.TryParseAt"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseAt()
{
// 指定したパーサーで該当のインデックスの文字を解析する
Assert.IsTrue(parser.TryParseAt("a", 0, out element, parser));
Assert.AreEqual("a", element.ToString());
- Assert.IsFalse(parser.TryParseAt("test[[test]]", 4, out element));
+ Assert.IsFalse(parser.TryParseAt("test[[TestMethod]]", 4, out element));
Assert.IsNull(element);
- Assert.IsTrue(parser.TryParseAt("test[[test]]", 4, out element, parser));
- Assert.AreEqual("[[test]]", element.ToString());
+ Assert.IsTrue(parser.TryParseAt("test[[TestMethod]]", 4, out element, parser));
+ Assert.AreEqual("[[TestMethod]]", element.ToString());
parser.Success = false;
Assert.IsFalse(parser.TryParseAt("a", 0, out element, parser));
Assert.IsNull(element);
- Assert.IsFalse(parser.TryParseAt("test[[test]]", 4, out element, parser));
+ Assert.IsFalse(parser.TryParseAt("test[[TestMethod]]", 4, out element, parser));
Assert.IsNull(element);
}
/// <summary>
/// <see cref="AbstractParser.TryParseAt"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestTryParseAtNull()
{
/// <summary>
/// <see cref="AbstractParser.TryParseAt"/>メソッドテストケース（範囲外）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void TestTryParseAtOutOfRange()
{
IElement element;
TestParser parser = new TestParser();
parser.Success = true;
- parser.TryParseAt(String.Empty, 1, out element);
+ parser.TryParseAt(string.Empty, 1, out element);
}
#endregion
using System.Collections.Generic;
using System.Text;
using Honememo.Utilities;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="AbstractTextParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class AbstractTextParserTest
{
#region インタフェース実装メソッドテストケース
/// <summary>
/// <see cref="AbstractTextParser.TryParseToEndCondition"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseToEndCondition()
{
IElement element;
Assert.IsFalse(parser.TryParseToEndCondition(null, null, out element));
Assert.IsNull(element);
- Assert.IsTrue(parser.TryParseToEndCondition(String.Empty, null, out element));
- Assert.AreEqual(String.Empty, element.ToString());
- Assert.IsInstanceOf(typeof(TextElement), element);
+ Assert.IsTrue(parser.TryParseToEndCondition(string.Empty, null, out element));
+ Assert.AreEqual(string.Empty, element.ToString());
+ Assert.IsInstanceOfType(element, typeof(TextElement));
Assert.IsTrue(parser.TryParseToEndCondition("0123456789", null, out element));
Assert.AreEqual("0123456789", element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
ListElement list = (ListElement)element;
Assert.AreEqual(10, list.Count);
foreach (IElement e in list)
{
- Assert.IsInstanceOf(typeof(TextElement), e);
+ Assert.IsInstanceOfType(e, typeof(TextElement));
}
// conditionが指定されている場合は、その条件を満たすまで
(string s, int index) => s[index] == '5',
out element));
Assert.AreEqual("01234", element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
}
/// <summary>
/// <see cref="AbstractTextParser.TryParseToDelimiter"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseToDelimiter()
{
IElement element;
Assert.IsFalse(parser.TryParseToDelimiter(null, out element));
Assert.IsNull(element);
- Assert.IsTrue(parser.TryParseToDelimiter(String.Empty, out element));
- Assert.AreEqual(String.Empty, element.ToString());
- Assert.IsInstanceOf(typeof(TextElement), element);
+ Assert.IsTrue(parser.TryParseToDelimiter(string.Empty, out element));
+ Assert.AreEqual(string.Empty, element.ToString());
+ Assert.IsInstanceOfType(element, typeof(TextElement));
- Assert.IsTrue(parser.TryParseToDelimiter("[[test]] is good", out element));
- Assert.AreEqual("[[test]] is good", element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsTrue(parser.TryParseToDelimiter("[[TestMethod]] is good", out element));
+ Assert.AreEqual("[[TestMethod]] is good", element.ToString());
+ Assert.IsInstanceOfType(element, typeof(ListElement));
// delimitersが指定されている場合は、その文字列まで
// ※ 本当は "test]] is good" にした状態で用いる
- Assert.IsTrue(parser.TryParseToDelimiter("[[test]] is good", out element, "]]"));
+ Assert.IsTrue(parser.TryParseToDelimiter("[[TestMethod]] is good", out element, "]]"));
Assert.AreEqual("[[test", element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
// delimitersは複数指定可能、先に見つけたもの優先
- Assert.IsTrue(parser.TryParseToDelimiter("[[test]] is good", out element, "]]", "s"));
+ Assert.IsTrue(parser.TryParseToDelimiter("[[TestMethod]] is good", out element, "]]", "s"));
Assert.AreEqual("[[te", element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
// delimitersの指定があっても見つからないときは最後まで処理する
- Assert.IsTrue(parser.TryParseToDelimiter("[[test]] is good", out element, "}}"));
- Assert.AreEqual("[[test]] is good", element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsTrue(parser.TryParseToDelimiter("[[TestMethod]] is good", out element, "}}"));
+ Assert.AreEqual("[[TestMethod]] is good", element.ToString());
+ Assert.IsInstanceOfType(element, typeof(ListElement));
}
/// <summary>
/// <see cref="AbstractTextParser.TryParseToDelimiter"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestTryParseToDelimiterNull()
{
/// <summary>
/// <see cref="AbstractTextParser.TryParse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParse()
{
IElement element;
Assert.IsFalse(parser.TryParse(null, out element));
Assert.IsNull(element);
- Assert.IsTrue(parser.TryParse(String.Empty, out element));
- Assert.AreEqual(String.Empty, element.ToString());
- Assert.IsInstanceOf(typeof(TextElement), element);
+ Assert.IsTrue(parser.TryParse(string.Empty, out element));
+ Assert.AreEqual(string.Empty, element.ToString());
+ Assert.IsInstanceOfType(element, typeof(TextElement));
Assert.IsTrue(parser.TryParse("0123456789", out element));
Assert.AreEqual("0123456789", element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
ListElement list = (ListElement)element;
}
/// <summary>
/// <see cref="AbstractTextParser.FlashText"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestFlashText()
{
// ビルダーに値が詰まっている場合、その内容をリストに追加してクリアする
parser.FlashText(ref list, ref b);
Assert.AreEqual(0, list.Count);
- Assert.AreEqual(String.Empty, b.ToString());
+ Assert.AreEqual(string.Empty, b.ToString());
b.Append("1st string");
parser.FlashText(ref list, ref b);
Assert.AreEqual(1, list.Count);
Assert.AreEqual("1st string", list[0].ToString());
- Assert.IsInstanceOf(typeof(TextElement), list[0]);
- Assert.AreEqual(String.Empty, b.ToString());
+ Assert.IsInstanceOfType(list[0], typeof(TextElement));
+ Assert.AreEqual(string.Empty, b.ToString());
b.Append("2nd string");
parser.FlashText(ref list, ref b);
Assert.AreEqual(2, list.Count);
Assert.AreEqual("1st string", list[0].ToString());
Assert.AreEqual("2nd string", list[1].ToString());
- Assert.IsInstanceOf(typeof(TextElement), list[1]);
- Assert.AreEqual(String.Empty, b.ToString());
+ Assert.IsInstanceOfType(list[1], typeof(TextElement));
+ Assert.AreEqual(string.Empty, b.ToString());
}
/// <summary>
/// <see cref="AbstractTextParser.FlashText"/>メソッドテストケース（リストがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestFlashTextListNull()
{
/// <summary>
/// <see cref="AbstractTextParser.FlashText"/>メソッドテストケース（ビルダーがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestFlashTextBNull()
{
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="CacheParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class CacheParserTest
{
#region コンストラクタテストケース
/// コンストラクタテストケース（異常系）。
/// </summary>
/// <remarks>正常系は他のメソッドのテストの中で実施。</remarks>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorNull()
{
/// <summary>
/// <see cref="CacheParser.Parse"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestParse()
{
// ラップしているパーサーと同じ結果を返すこと
/// <summary>
/// <see cref="CacheParser.Parse"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestParseNull()
{
/// <summary>
/// <see cref="CacheParser.Parse"/>メソッドテストケース（解析失敗）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(FormatException))]
public void TestParseIgnore()
{
/// <summary>
/// <see cref="CacheParser.TryParse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParse()
{
// ラップしているパーサーと同じ結果を返すこと
/// <summary>
/// <see cref="CacheParser.IsPossibleParse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsPossibleParse()
{
// ラップしているパーサーと同じ結果を返すこと
{
using System;
using System.Collections.Generic;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// HtmlElementのテストクラスです。
+ /// <see cref="HtmlElement"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class HtmlElementTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
HtmlElement element = new HtmlElement("testname1");
Assert.AreEqual("testname2", element.Name);
Assert.AreEqual(0, element.Attributes.Count);
Assert.AreEqual(1, element.Count);
- Assert.IsInstanceOf(typeof(TextElement), element[0]);
+ Assert.IsInstanceOfType(element[0], typeof(TextElement));
Assert.AreEqual("testvalue", element[0].ToString());
IDictionary<string, string> attribute = new Dictionary<string, string>();
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
HtmlElement element = new HtmlElement("form");
Assert.AreEqual("<form>", element.ToString());
element.Attributes.Add("action", "/test.html");
Assert.AreEqual("<form action=\"/test.html\">", element.ToString());
- element.Attributes.Add("disabled", String.Empty);
+ element.Attributes.Add("disabled", string.Empty);
Assert.AreEqual("<form action=\"/test.html\" disabled=\"\">", element.ToString());
element.Add(new TextElement("フォーム内のテキスト"));
Assert.AreEqual("<form action=\"/test.html\" disabled=\"\">フォーム内のテキスト</form>", element.ToString());
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// ListElementのテストクラスです。
+ /// <see cref="ListElement"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class ListElementTest
{
#region インタフェース実装プロパティテストケース
/// <summary>
/// ParsedStringプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestParsedString()
{
ListElement element = new ListElement();
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
ListElement element = new ListElement();
- Assert.IsEmpty(element.ToString());
+ Assert.AreEqual(string.Empty, element.ToString());
element.Add(new TextElement { Text = "test1" });
Assert.AreEqual("test1", element.ToString());
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// TextElementのテストクラスです。
+ /// <see cref="TextElement"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class TextElementTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
TextElement element = new TextElement();
/// <summary>
/// Textプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestText()
{
TextElement element = new TextElement();
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
TextElement element = new TextElement();
- Assert.IsEmpty(element.ToString());
+ Assert.AreEqual(string.Empty, element.ToString());
element.Text = "test";
Assert.AreEqual("test", element.ToString());
}
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="XmlCommentElementParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class XmlCommentElementParserTest
{
#region インタフェース実装メソッドテストケース
/// <summary>
/// <see cref="XmlCommentElementParser.TryParse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParse()
{
XmlCommentElementParser parser = new XmlCommentElementParser();
Assert.IsNull(comment);
Assert.IsFalse(parser.TryParse("<! --test-->", out comment));
Assert.IsNull(comment);
- Assert.IsFalse(parser.TryParse(String.Empty, out comment));
+ Assert.IsFalse(parser.TryParse(string.Empty, out comment));
Assert.IsNull(comment);
Assert.IsFalse(parser.TryParse(null, out comment));
Assert.IsNull(comment);
/// <summary>
/// <see cref="XmlCommentElementParser.IsPossibleParse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsPossibleParse()
{
XmlCommentElementParser parser = new XmlCommentElementParser();
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// XmlCommentElementのテストクラスです。
+ /// <see cref="XmlCommentElement"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class XmlCommentElementTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
XmlCommentElement comment = new XmlCommentElement();
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
XmlCommentElement comment = new XmlCommentElement();
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="XmlElementParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class XmlElementParserTest
{
#region private変数
/// テストの前処理。
/// </summary>
/// <remarks><see cref="XmlParser.Dispose"/>が必要な<see cref="XmlParser"/>の生成。</remarks>
- [SetUp]
+ [TestInitialize]
public void SetUp()
{
this.xmlParser = new XmlParser();
/// テストの後処理。
/// </summary>
/// <remarks><see cref="XmlParser.Dispose"/>が必要な<see cref="XmlParser"/>の解放。</remarks>
- [TearDown]
+ [TestCleanup]
public void TearDown()
{
this.xmlParser.Dispose();
/// <summary>
/// <see cref="XmlElementParser.Targets"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTargets()
{
XmlElementParser parser = new XmlElementParser(this.xmlParser);
/// <summary>
/// <see cref="XmlElementParser.Targets"/>プロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestTargetsNull()
{
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（実例）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParse()
{
IElement element;
Assert.AreEqual("checkbox", xmlElement.Attributes["type"]);
Assert.AreEqual("param", xmlElement.Attributes["name"]);
Assert.AreEqual("test", xmlElement.Attributes["value"]);
- Assert.IsEmpty(xmlElement.Attributes["checked"]);
+ Assert.AreEqual(string.Empty, xmlElement.Attributes["checked"]);
Assert.IsTrue(parser.TryParse("<div id=\"outer\">outertext<div id=\"inner\">innertext</div></div>", out element));
xmlElement = (XmlElement)element;
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（基本形）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNormal()
{
IElement element;
Assert.IsTrue(parser.TryParse("<testtag5 testattr2='testvalue2'>testbody</testtag5 >testend", out element));
xmlElement = (XmlElement)element;
- Assert.IsInstanceOf(typeof(XmlTextElement), xmlElement[0]);
+ Assert.IsInstanceOfType(xmlElement[0], typeof(XmlTextElement));
Assert.AreEqual("<testtag5 testattr2='testvalue2'>testbody</testtag5 >", xmlElement.ToString());
Assert.AreEqual("testtag5", xmlElement.Name);
Assert.AreEqual(1, xmlElement.Attributes.Count);
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（普通でNGパターン）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNormalNg()
{
IElement element;
Assert.IsNull(element);
Assert.IsFalse(parser.TryParse("<!-- comment -->", out element));
Assert.IsNull(element);
- Assert.IsFalse(parser.TryParse(String.Empty, out element));
+ Assert.IsFalse(parser.TryParse(string.Empty, out element));
Assert.IsNull(element);
Assert.IsFalse(parser.TryParse(null, out element));
Assert.IsNull(element);
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（単一のパターン）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseSingle()
{
IElement element;
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（不正な構文）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseLazy()
{
IElement element;
Assert.AreEqual("testtag2", xmlElement.Name);
Assert.AreEqual(2, xmlElement.Attributes.Count);
Assert.AreEqual("test", xmlElement.Attributes["testattr"]);
- Assert.IsEmpty(xmlElement.Attributes["value"]);
+ Assert.AreEqual(string.Empty, xmlElement.Attributes["value"]);
Assert.IsTrue(parser.TryParse("<testtag3>test value2</ testtag3>testend", out element));
xmlElement = (XmlElement)element;
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（不正でNG）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseLazyNg()
{
IElement element;
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（HTML）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseHtml()
{
IElement element;
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（大文字小文字）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseIgnoreCase()
{
IElement element;
/// <summary>
/// <see cref="XmlElementParser.TryParse"/>メソッドテストケース（タグ限定）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseTargets()
{
IElement element;
/// <summary>
/// <see cref="XmlElementParser.IsPossibleParse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsElementPossible()
{
XmlElementParser parser = new XmlElementParser(new XmlParser());
{
using System;
using System.Collections.Generic;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// XmlElementのテストクラスです。
+ /// <see cref="XmlElement"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class XmlElementTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
XmlElement element = new XmlElement("testname1");
Assert.AreEqual("testname2", element.Name);
Assert.AreEqual(0, element.Attributes.Count);
Assert.AreEqual(1, element.Count);
- Assert.IsInstanceOf(typeof(TextElement), element[0]);
+ Assert.IsInstanceOfType(element[0], typeof(TextElement));
Assert.AreEqual("testvalue", element[0].ToString());
IDictionary<string, string> attribute = new Dictionary<string, string>();
/// <summary>
/// Nameプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestName()
{
XmlElement element = new XmlElement("testname1");
/// <summary>
/// Nameプロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestNameNull()
{
/// <summary>
/// Nameプロパティテストケース（空文字列）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestNameEmpty()
{
- XmlElement element = new XmlElement(String.Empty);
+ XmlElement element = new XmlElement(string.Empty);
}
/// <summary>
/// Nameプロパティテストケース（空白文字列）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestNameBlank()
{
/// <summary>
/// Attributesプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAttributes()
{
XmlElement element = new XmlElement("testname");
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
XmlElement element = new XmlElement("form");
Assert.AreEqual("<form />", element.ToString());
element.Attributes.Add("action", "/test.html");
Assert.AreEqual("<form action=\"/test.html\" />", element.ToString());
- element.Attributes.Add("disabled", String.Empty);
+ element.Attributes.Add("disabled", string.Empty);
Assert.AreEqual("<form action=\"/test.html\" disabled=\"\" />", element.ToString());
element.Add(new TextElement("フォーム内のテキスト"));
Assert.AreEqual("<form action=\"/test.html\" disabled=\"\">フォーム内のテキスト</form>", element.ToString());
using System;
using System.Collections.Generic;
using System.Linq;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="XmlParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class XmlParserTest
{
#region プロパティテストケース
/// <summary>
/// <see cref="XmlParser.Parsers"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestParsers()
{
using (XmlParser parser = new XmlParser())
/// <summary>
/// <see cref="XmlParser.Parsers"/>プロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestParsersNull()
{
/// <summary>
/// <see cref="XmlParser.IgnoreCase"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIgnoreCase()
{
using (XmlParser parser = new XmlParser())
/// <summary>
/// <see cref="XmlParser.IsHtml"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsHtml()
{
using (XmlParser parser = new XmlParser())
/// <summary>
/// <see cref="IParser.Parse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestParse()
{
using (XmlParser parser = new XmlParser())
Assert.AreEqual("test", parser.Parse("test").ToString());
IElement element = parser.Parse("testbefore<p>testinner</p><!--comment-->testafter");
- Assert.IsInstanceOf(typeof(ICollection<IElement>), element);
+ Assert.IsInstanceOfType(element, typeof(ICollection<IElement>));
ICollection<IElement> collection = (ICollection<IElement>)element;
Assert.AreEqual(4, collection.Count);
Assert.AreEqual("testbefore", collection.ElementAt(0).ToString());
- Assert.IsInstanceOf(typeof(XmlElement), collection.ElementAt(1));
+ Assert.IsInstanceOfType(collection.ElementAt(1), typeof(XmlElement));
Assert.AreEqual("<p>testinner</p>", collection.ElementAt(1).ToString());
- Assert.IsInstanceOf(typeof(XmlCommentElement), collection.ElementAt(2));
+ Assert.IsInstanceOfType(collection.ElementAt(2), typeof(XmlCommentElement));
Assert.AreEqual("<!--comment-->", collection.ElementAt(2).ToString());
Assert.AreEqual("testafter", collection.ElementAt(3).ToString());
}
/// <summary>
/// <see cref="IParser.Parse"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestParseNull()
{
/// <summary>
/// <see cref="IParser.Parse"/>メソッドテストケース（Dispose）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public void TestParseDispose()
{
/// <summary>
/// <see cref="XmlParser.Dispose"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestDispose()
{
// 循環参照のあるParsersを解放する
namespace Honememo.Parsers
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// XmlTextElementのテストクラスです。
+ /// <see cref="XmlTextElement"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class XmlTextElementTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
XmlTextElement element = new XmlTextElement();
/// <summary>
/// Textプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestText()
{
XmlTextElement element = new XmlTextElement();
/// <summary>
/// Rawプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestRaw()
{
XmlTextElement element = new XmlTextElement();
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
XmlTextElement element = new XmlTextElement();
- Assert.IsEmpty(element.ToString());
+ Assert.AreEqual(string.Empty, element.ToString());
element.Text = "test";
Assert.AreEqual("test", element.ToString());
element.Text = "<test> & \"test'";
// すべての値を指定するか、下のように '*' を使ってビルドおよびリビジョン番号を
// 既定値にすることができます:
// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.3.*")]
+[assembly: AssemblyVersion("0.4.*")]
namespace Honememo.Utilities
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// CollectionUtilsのテストクラスです。
+ /// <see cref="CollectionUtils"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class CollectionUtilsTest
{
#region 比較メソッドテストケース
/// <summary>
/// ContainsIgnoreCaseメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestContainsIgnoreCase()
{
string[] array = new string[0];
Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, null));
- Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, String.Empty));
+ Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, string.Empty));
Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, "test"));
array = new string[] { "test" };
Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, null));
- Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, String.Empty));
+ Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, string.Empty));
Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, "test"));
Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, "teST"));
Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, "TEST"));
array = new string[] { "Test", null, "日本語" };
Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, null));
- Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, String.Empty));
+ Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, string.Empty));
Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, "test"));
Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, "日本語"));
- array = new string[] { "Test", String.Empty, "日本語" };
+ array = new string[] { "Test", string.Empty, "日本語" };
Assert.IsFalse(CollectionUtils.ContainsIgnoreCase(array, null));
- Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, String.Empty));
+ Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, string.Empty));
Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, "test"));
Assert.IsTrue(CollectionUtils.ContainsIgnoreCase(array, "日本語"));
}
/// <summary>
/// ContainsIgnoreCaseメソッドテストケース（異常系）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestContainsIgnoreCaseNull()
{
/// <summary>
/// Trimメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTrim()
{
Assert.AreEqual(0, CollectionUtils.Trim(new string[0]).Length);
Assert.AreEqual(1, CollectionUtils.Trim(new string[] { "test" }).Length);
- Assert.AreEqual(
- new string[] { "test" },
- CollectionUtils.Trim(new string[] { " test " }));
- Assert.AreEqual(
- new string[] { "Test", null, "日本語" },
- CollectionUtils.Trim(new string[] { " Test", null, "日本語 " }));
- Assert.AreEqual(
- new string[] { "Te st", String.Empty, "日 本 語" },
- CollectionUtils.Trim(new string[] { "Te st ", " ", " 日 本 語 " }));
+
+ string[] actual = CollectionUtils.Trim(new string[] { " test " });
+ Assert.AreEqual("test", actual[0]);
+
+ actual = CollectionUtils.Trim(new string[] { " Test", null, "日本語 " });
+ Assert.AreEqual("Test", actual[0]);
+ Assert.IsNull(actual[1]);
+ Assert.AreEqual("日本語", actual[2]);
+
+ actual = CollectionUtils.Trim(new string[] { "Te st ", " ", " 日 本 語 " });
+ Assert.AreEqual("Te st", actual[0]);
+ Assert.AreEqual(string.Empty, actual[1]);
+ Assert.AreEqual("日 本 語", actual[2]);
}
/// <summary>
/// Trimメソッドテストケース（異常系）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestTrimNull()
{
{
using System;
using System.Threading.Tasks;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="LockObject"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class LockObjectTest
{
#region パラメータ単位のロック用メソッドテストケース
/// <summary>
/// <see cref="LockObject.GetObject"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetObject()
{
// 同じ入力に同じオブジェクトが、違う入力には違うオブジェクトが返ること
/// <summary>
/// <see cref="LockObject.GetObject"/>メソッドテストケース（並列実行）。
/// </summary>
- [Test, Timeout(1500)]
+ [TestMethod, Timeout(1500)]
public void TestGetObjectParallel()
{
// 同じ入力に同じオブジェクトが返ること
/// <summary>
/// <see cref="LockObject.GetObject"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestGetObjectNull()
{
namespace Honememo.Utilities
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// ObjectUtilsのテストクラスです。
+ /// <see cref="ObjectUtils"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class ObjectUtilsTest
{
#region 初期化メソッドテストケース
/// <summary>
/// Equalsメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestDefaultIfNull()
{
Assert.IsNull(ObjectUtils.DefaultIfNull<object>(null, null));
- Assert.AreEqual(String.Empty, ObjectUtils.DefaultIfNull(String.Empty, "null"));
+ Assert.AreEqual(string.Empty, ObjectUtils.DefaultIfNull(string.Empty, "null"));
Assert.AreEqual("not null", ObjectUtils.DefaultIfNull("not null", "null"));
Assert.AreEqual("null", ObjectUtils.DefaultIfNull(null, "null"));
}
/// <summary>
/// Equalsメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestEquals()
{
Assert.IsTrue(ObjectUtils.Equals(null, null));
- Assert.IsFalse(ObjectUtils.Equals(null, String.Empty));
- Assert.IsFalse(ObjectUtils.Equals(String.Empty, null));
- Assert.IsTrue(ObjectUtils.Equals(String.Empty, String.Empty));
+ Assert.IsFalse(ObjectUtils.Equals(null, string.Empty));
+ Assert.IsFalse(ObjectUtils.Equals(string.Empty, null));
+ Assert.IsTrue(ObjectUtils.Equals(string.Empty, string.Empty));
Assert.IsFalse(ObjectUtils.Equals(true, null));
Assert.IsFalse(ObjectUtils.Equals(true, "true"));
Assert.IsTrue(ObjectUtils.Equals(true, true));
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
// 引数二つ
Assert.IsNull(ObjectUtils.ToString(null, null));
- Assert.AreEqual(String.Empty, ObjectUtils.ToString(String.Empty, "null"));
+ Assert.AreEqual(string.Empty, ObjectUtils.ToString(string.Empty, "null"));
Assert.AreEqual("not null", ObjectUtils.ToString("not null", "null"));
Assert.AreEqual("null", ObjectUtils.ToString(null, "null"));
- Assert.IsNotEmpty(ObjectUtils.ToString(new object(), null));
+ Assert.IsTrue(ObjectUtils.ToString(new object(), null).Length > 0);
// 引数一つ
- Assert.AreEqual(String.Empty, ObjectUtils.ToString(null));
+ Assert.AreEqual(string.Empty, ObjectUtils.ToString(null));
Assert.AreEqual("not null", ObjectUtils.ToString("not null"));
- Assert.IsNotEmpty(ObjectUtils.ToString(new object()));
+ Assert.IsTrue(ObjectUtils.ToString(new object()).Length > 0);
}
#endregion
namespace Honememo.Utilities
{
using System;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="StatusManager<T>"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class StatusManagerTest
{
#region プロパティテストケース
/// <summary>
/// <see cref="StatusManager<T>.Status"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestStatus()
{
var sm = new StatusManager<string>();
/// <see cref="StatusManager<T>.Switch"/>,
/// <see cref="StatusManager<T>.Dispose"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestSwitch()
{
var sm = new StatusManager<string>();
/// <summary>
/// <see cref="StatusManager<T>.Clear"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestClear()
{
var sm = new StatusManager<int>();
{
using System;
using System.Text;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// StringUtilsのテストクラスです。
+ /// <see cref="StringUtils"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class StringUtilsTest
{
#region 初期化メソッドテストケース
/// <summary>
/// DefaultStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestDefaultString()
{
// 引数一つ
- Assert.IsEmpty(StringUtils.DefaultString(null));
- Assert.IsEmpty(StringUtils.DefaultString(String.Empty));
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(null));
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(string.Empty));
Assert.AreEqual(" ", StringUtils.DefaultString(" "));
Assert.AreEqual("null以外の文字列", StringUtils.DefaultString("null以外の文字列"));
// 引数二つ
Assert.AreEqual("初期値", StringUtils.DefaultString(null, "初期値"));
- Assert.IsEmpty(StringUtils.DefaultString(String.Empty, "初期値"));
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(string.Empty, "初期値"));
Assert.AreEqual(" ", StringUtils.DefaultString(" ", "初期値"));
Assert.AreEqual("null以外の文字列", StringUtils.DefaultString("null以外の文字列", "初期値"));
}
/// <summary>
/// Substringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestSubstring()
{
// 引数一つ
Assert.IsNull(StringUtils.Substring(null, 0));
Assert.AreEqual("abc", StringUtils.Substring("abc", 0));
Assert.AreEqual("c", StringUtils.Substring("abc", 2));
- Assert.IsEmpty(StringUtils.Substring("abc", 4));
+ Assert.AreEqual(string.Empty, StringUtils.Substring("abc", 4));
Assert.AreEqual("abc", StringUtils.Substring("abc", -2));
Assert.AreEqual("abc", StringUtils.Substring("abc", -4));
Assert.AreEqual("3", StringUtils.Substring("0123", 3));
- Assert.IsEmpty(StringUtils.Substring("0123", 4));
+ Assert.AreEqual(string.Empty, StringUtils.Substring("0123", 4));
// 引数二つ
Assert.IsNull(StringUtils.Substring(null, 0, 0));
- Assert.IsEmpty(StringUtils.Substring(String.Empty, 0, 1));
+ Assert.AreEqual(string.Empty, StringUtils.Substring(string.Empty, 0, 1));
Assert.AreEqual("ab", StringUtils.Substring("abc", 0, 2));
- Assert.IsEmpty(StringUtils.Substring("abc", 2, 0));
+ Assert.AreEqual(string.Empty, StringUtils.Substring("abc", 2, 0));
Assert.AreEqual("c", StringUtils.Substring("abc", 2, 2));
- Assert.IsEmpty(StringUtils.Substring("abc", 4, 2));
- Assert.IsEmpty(StringUtils.Substring("abc", -2, -1));
+ Assert.AreEqual(string.Empty, StringUtils.Substring("abc", 4, 2));
+ Assert.AreEqual(string.Empty, StringUtils.Substring("abc", -2, -1));
Assert.AreEqual("ab", StringUtils.Substring("abc", -4, 2));
Assert.AreEqual("3", StringUtils.Substring("0123", 3, 1));
Assert.AreEqual("3", StringUtils.Substring("0123", 3, 2));
- Assert.IsEmpty(StringUtils.Substring("0123", 4, 1));
+ Assert.AreEqual(string.Empty, StringUtils.Substring("0123", 4, 1));
}
#endregion
/// <summary>
/// StartsWithメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestStartsWith()
{
// null
Assert.IsTrue(StringUtils.StartsWith(null, null, 3));
- Assert.IsFalse(StringUtils.StartsWith(null, String.Empty, 2));
- Assert.IsFalse(StringUtils.StartsWith(String.Empty, null, 5));
+ Assert.IsFalse(StringUtils.StartsWith(null, string.Empty, 2));
+ Assert.IsFalse(StringUtils.StartsWith(string.Empty, null, 5));
// 空、文字数
- Assert.IsFalse(StringUtils.StartsWith(String.Empty, String.Empty, 0));
- Assert.IsTrue(StringUtils.StartsWith("a", String.Empty, 0));
- Assert.IsTrue(StringUtils.StartsWith("abcedf0123あいうえお", String.Empty, 14));
- Assert.IsFalse(StringUtils.StartsWith("abcedf0123あいうえお", String.Empty, 15));
- Assert.IsFalse(StringUtils.StartsWith("abcedf0123あいうえお", String.Empty, -1));
+ Assert.IsFalse(StringUtils.StartsWith(string.Empty, string.Empty, 0));
+ Assert.IsTrue(StringUtils.StartsWith("a", string.Empty, 0));
+ Assert.IsTrue(StringUtils.StartsWith("abcedf0123あいうえお", string.Empty, 14));
+ Assert.IsFalse(StringUtils.StartsWith("abcedf0123あいうえお", string.Empty, 15));
+ Assert.IsFalse(StringUtils.StartsWith("abcedf0123あいうえお", string.Empty, -1));
// 通常
Assert.IsTrue(StringUtils.StartsWith("abcedf0123あいうえお", "bc", 1));
/// <summary>
/// StartsWithメソッドテストケース（性能試験）。
/// </summary>
- [Test, Timeout(1500)]
+ [TestMethod, Timeout(1500)]
public void TestStartsWithResponse()
{
// テストデータとして適当な、ただしある文字が定期的に出現する長い文字列を生成
int span = 0x7D - 0x20;
for (int i = 0; i < 100000; i++)
{
- b.Append(Char.ConvertFromUtf32((i % span) + 0x20));
+ b.Append(char.ConvertFromUtf32((i % span) + 0x20));
}
// 先頭から最後までひたすら実行して時間がかかりすぎないかをチェック
/// <summary>
/// FormatDollarVariableメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestFormatDollarVariable()
{
// 空文字列
- Assert.IsEmpty(StringUtils.FormatDollarVariable(String.Empty));
- Assert.IsEmpty(StringUtils.FormatDollarVariable(String.Empty, String.Empty));
+ Assert.AreEqual(string.Empty, StringUtils.FormatDollarVariable(string.Empty));
+ Assert.AreEqual(string.Empty, StringUtils.FormatDollarVariable(string.Empty, string.Empty));
// 通常
Assert.AreEqual("test", StringUtils.FormatDollarVariable("test"));
/// <summary>
/// FormatDollarVariableメソッドテストケース（書式がnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestFormatDollarVariableFormatNull()
{
/// <summary>
/// FormatDollarVariableメソッドテストケース（パラメータがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestFormatDollarVariableArgsNull()
{
- StringUtils.FormatDollarVariable(String.Empty, null);
+ StringUtils.FormatDollarVariable(string.Empty, null);
}
#endregion
/// <summary>
/// CompareNullsLastメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCompareNullsLast()
{
// 通常のString.Compareと同じ動作
Assert.AreEqual(-1, StringUtils.CompareNullsLast("ab", "abc"));
Assert.AreEqual(1, StringUtils.CompareNullsLast("abc", "ab"));
Assert.AreEqual(0, StringUtils.CompareNullsLast(null, null));
- Assert.AreEqual(0, StringUtils.CompareNullsLast(String.Empty, String.Empty));
+ Assert.AreEqual(0, StringUtils.CompareNullsLast(string.Empty, string.Empty));
// 独自の拡張部分、nullや空の値が大きいと判断される
Assert.AreEqual(-1, StringUtils.CompareNullsLast("abc", null));
Assert.AreEqual(1, StringUtils.CompareNullsLast(null, "abc"));
- Assert.AreEqual(-1, StringUtils.CompareNullsLast("abc", String.Empty));
- Assert.AreEqual(1, StringUtils.CompareNullsLast(String.Empty, "abc"));
+ Assert.AreEqual(-1, StringUtils.CompareNullsLast("abc", string.Empty));
+ Assert.AreEqual(1, StringUtils.CompareNullsLast(string.Empty, "abc"));
// nullと空の場合nullの方が大きいと判定
- Assert.AreEqual(1, StringUtils.CompareNullsLast(null, String.Empty));
- Assert.AreEqual(-1, StringUtils.CompareNullsLast(String.Empty, null));
+ Assert.AreEqual(1, StringUtils.CompareNullsLast(null, string.Empty));
+ Assert.AreEqual(-1, StringUtils.CompareNullsLast(string.Empty, null));
}
#endregion
{
using System;
using System.Collections.Generic;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="Validate"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class ValidateTest
{
#region NotNullメソッドテストケース
/// <summary>
/// <see cref="Validate.NotNull<T>(T, string)"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNotNull()
{
// パラメータ名指定無し
- Assert.AreEqual(String.Empty, Validate.NotNull(String.Empty));
+ Assert.AreEqual(string.Empty, Validate.NotNull(string.Empty));
Assert.AreEqual("not null", Validate.NotNull("not null"));
// パラメータ名指定有り
- Assert.AreEqual(String.Empty, Validate.NotNull(String.Empty, null));
- Assert.AreEqual(String.Empty, Validate.NotNull(String.Empty, "test"));
+ Assert.AreEqual(string.Empty, Validate.NotNull(string.Empty, null));
+ Assert.AreEqual(string.Empty, Validate.NotNull(string.Empty, "test"));
Assert.AreEqual("not null", Validate.NotNull("not null", "test"));
}
/// <summary>
/// <see cref="Validate.NotNull<T>(T, string)"/>メソッドテストケース（異常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNotNullNg()
{
// obj = nullのチェック
/// <summary>
/// <see cref="Validate.NotEmpty(string, string)"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNotEmpty()
{
// パラメータ名指定無し
/// <summary>
/// <see cref="Validate.NotEmpty(string, string)"/>メソッドテストケース（異常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNotEmptyNg()
{
// str = nullのチェック
try
{
// パラメータ名指定無し
- Validate.NotEmpty(String.Empty);
+ Validate.NotEmpty(string.Empty);
Assert.Fail("expected ArgumentException");
}
catch (ArgumentException ex)
try
{
// パラメータ名指定有り
- Validate.NotEmpty(String.Empty, "test");
+ Validate.NotEmpty(string.Empty, "test");
Assert.Fail("expected ArgumentException");
}
catch (ArgumentException ex)
/// <summary>
/// <see cref="Validate.NotBlank(string, string)"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNotBlank()
{
// パラメータ名指定無し
/// <summary>
/// <see cref="Validate.NotBlank(string, string)"/>メソッドテストケース（異常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNotBlankNg()
{
// str = nullのチェック
/// <see cref="Validate.InRange(string, int, string, string)"/>
/// メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestInRangeStr()
{
// ※ 例外が起きなければOK
/// <see cref="Validate.InRange(string, int, string, string)"/>
/// メソッドテストケース（異常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestInRangeStrNg()
{
// str = nullのチェック
try
{
// パラメータ名指定無し
- Validate.InRange(String.Empty, 0);
+ Validate.InRange(string.Empty, 0);
Assert.Fail("expected ArgumentOutOfRangeException");
}
catch (ArgumentOutOfRangeException ex)
try
{
// パラメータ名指定有り
- Validate.InRange(String.Empty, 0, "test", "testindex");
+ Validate.InRange(string.Empty, 0, "test", "testindex");
Assert.Fail("expected ArgumentOutOfRangeException");
}
catch (ArgumentOutOfRangeException ex)
try
{
// パラメータ名指定有りnull
- Validate.InRange(String.Empty, 0, null, null);
+ Validate.InRange(string.Empty, 0, null, null);
Assert.Fail("expected ArgumentOutOfRangeException");
}
catch (ArgumentOutOfRangeException ex)
/// <see cref="Validate.InRange<T>(IList<T>, int, string, string)"/>
/// メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestInRangeIList()
{
// ※ 例外が起きなければOK
/// <see cref="Validate.InRange<T>(IList<T>, int, string, string)"/>
/// メソッドテストケース（異常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestInRangeIListNg()
{
// list = nullのチェック
{
using System;
using System.Xml;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// XmlUtilsのテストクラスです。
+ /// <see cref="XmlUtils"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class XmlUtilsTest
{
#region null値許容メソッドテストケース
/// <summary>
/// InnerTextメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestInnerText()
{
// 引数一つ
- Assert.AreEqual(String.Empty, XmlUtils.InnerText(null));
+ Assert.AreEqual(string.Empty, XmlUtils.InnerText(null));
Assert.AreEqual("test", XmlUtils.InnerText(new XmlDocument { InnerXml = "<dummy>test</dummy>" }));
// 引数二つ
/// <summary>
/// InnerXmlメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestInnerXml()
{
// 引数一つ
- Assert.AreEqual(String.Empty, XmlUtils.InnerXml(null));
+ Assert.AreEqual(string.Empty, XmlUtils.InnerXml(null));
Assert.AreEqual("<test />", XmlUtils.InnerXml(new XmlDocument { InnerXml = "<test />" }));
// 引数二つ
/// <summary>
/// OuterXmlメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestOuterXml()
{
// 引数一つ
- Assert.AreEqual(String.Empty, XmlUtils.OuterXml(null));
+ Assert.AreEqual(string.Empty, XmlUtils.OuterXml(null));
Assert.AreEqual("<test />", XmlUtils.OuterXml(new XmlDocument { InnerXml = "<test />" }));
// 引数二つ
/// <summary>
/// XmlEncodeメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestXmlEncode()
{
Assert.AreEqual("test", XmlUtils.XmlEncode("test"));
/// <summary>
/// XmlEncodeメソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestXmlEncodeNull()
{
/// <summary>
/// XmlDecodeメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestXmlDecode()
{
Assert.AreEqual("test", XmlUtils.XmlDecode("test"));
/// <summary>
/// XmlDecodeメソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestXmlDecodeNull()
{
setlocal
rem WiX\82È\82ç\82Ñ\82ÉWindows SDK\83C\83\93\83X\83g\81[\83\8b\83t\83H\83\8b\83_
-set WIX=C:\Program Files (x86)\Windows Installer XML v3.5
-set WINSDK=C:\Program Files\Microsoft SDKs\Windows\v7.0
-set PATH=%WIX%\bin;%WINSDK%\Bin;%WINSDK%\Samples\sysmgmt\msi\scripts;%PATH%
+set WIX=%ProgramFiles(x86)%\WiX Toolset v3.6
+set WINSDK=%ProgramFiles(x86)%\Microsoft SDKs\Windows\v7.1A
+set WINKIT=%ProgramFiles(x86)%\Windows Kits\8.0
+set PATH=%WIX%\bin;%WINSDK%\Bin;%WINKIT%\bin\x86;%PATH%
rem WiX\83r\83\8b\83h\83t\83@\83C\83\8b\81i\88È\89º\81A\83t\83@\83C\83\8b\96¼\82Í\82±\82Ì\83o\83b\83`\82©\82ç\82Ì\91\8a\91Î\83p\83X\81j
set WXS_FILE=Wptscs.wxs
{
// 入力値チェック
this.ConfigName = this.textBoxName.Text.Trim();
- if (String.IsNullOrEmpty(this.ConfigName))
+ if (string.IsNullOrEmpty(this.ConfigName))
{
FormUtils.WarningDialog(Resources.WarningMessageEmptyConfigName);
this.textBoxName.Focus();
{
FormUtils.WarningDialog(
Resources.WarningMessageInvalidConfigName,
- String.Join(", ", Path.GetInvalidFileNameChars()));
+ string.Join(", ", Path.GetInvalidFileNameChars()));
this.textBoxName.Focus();
return;
}
{
// 入力値チェック
this.LanguageCode = this.textBoxCode.Text.Trim();
- if (String.IsNullOrEmpty(this.LanguageCode))
+ if (string.IsNullOrEmpty(this.LanguageCode))
{
FormUtils.WarningDialog(Resources.WarningMessageEmptyLanguageCode);
this.textBoxCode.Focus();
// 空または日付として認識可能な値の場合OK
string value = e.FormattedValue.ToString();
DateTime dummy;
- if (String.IsNullOrWhiteSpace(value) || DateTime.TryParse(value, out dummy))
+ if (string.IsNullOrWhiteSpace(value) || DateTime.TryParse(value, out dummy))
{
return;
}
// ※ 他の列で消さないのは、エラーを出しているのがRowValidatingの場合もあるから
if (this.dataGridViewItems.Columns[e.ColumnIndex].Name == "ColumnTimestamp")
{
- this.dataGridViewItems.Rows[e.RowIndex].ErrorText = String.Empty;
+ this.dataGridViewItems.Rows[e.RowIndex].ErrorText = string.Empty;
}
}
if (e.RowIndex >= 0)
{
DataGridViewRow row = this.dataGridViewItems.Rows[e.RowIndex];
- if (String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnTimestamp"]))
+ if (string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnTimestamp"]))
&& !this.IsEmptyDataGridViewItemsRow(row))
{
// 背景色を変更
// 翻訳元、記事名、翻訳先が未入力の場合、バリデートNGメッセージを表示
// ※ ただし全列が空（新規行など）の場合は無視
DataGridViewRow row = this.dataGridViewItems.Rows[e.RowIndex];
- if ((String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnFromCode"]))
- || String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnToCode"]))
- || String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnFromTitle"])))
+ if ((string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnFromCode"]))
+ || string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnToCode"]))
+ || string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnFromTitle"])))
&& !this.IsEmptyDataGridViewItemsRow(row))
{
row.ErrorText = Resources.WarningMessageEmptyTranslationDictionary;
};
string timestamp = FormUtils.ToString(row.Cells["ColumnTimestamp"]);
- if (!String.IsNullOrWhiteSpace(timestamp))
+ if (!string.IsNullOrWhiteSpace(timestamp))
{
item.Timestamp = DateTime.Parse(timestamp);
/// <returns>空の場合<c>true</c>。</returns>
private bool IsEmptyDataGridViewItemsRow(DataGridViewRow row)
{
- return String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnFromCode"]))
- && String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnFromTitle"]))
- && String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnAlias"]))
- && String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnToCode"]))
- && String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnToTitle"]))
- && String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnTimestamp"]));
+ return string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnFromCode"]))
+ && string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnFromTitle"]))
+ && string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnAlias"]))
+ && string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnToCode"]))
+ && string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnToTitle"]))
+ && string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnTimestamp"]));
}
#endregion
}
// 改行区切りで表示
- row.Cells[cell.Key].Value = String.Join("\n", cell.Value);
+ row.Cells[cell.Key].Value = string.Join("\n", cell.Value);
}
}
{
// 空のセルは格納しない、該当の組み合わせは消える
string value = FormUtils.ToString(cell);
- if (!String.IsNullOrWhiteSpace(value))
+ if (!string.IsNullOrWhiteSpace(value))
{
// 改行区切りの配列で格納
record[cell.OwningColumn.Name] = CollectionUtils.Trim(value.Split('\n'));
if (lang.Names.TryGetValue(
Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName, out name))
{
- if (!String.IsNullOrEmpty(name.Name))
+ if (!string.IsNullOrEmpty(name.Name))
{
- return String.Format(Resources.HeadingViewHeaderText, name.Name, lang.Code);
+ return string.Format(Resources.HeadingViewHeaderText, name.Name, lang.Code);
}
}
try
{
// 変更前の設定を保存
- if (!String.IsNullOrEmpty(this.comboBoxLanguageSelectedText))
+ if (!string.IsNullOrEmpty(this.comboBoxLanguageSelectedText))
{
// 設定が存在しなければ自動生成される
this.SaveChangedValue(this.GetMediaWikiNeedCreate(this.config.Websites, this.comboBoxLanguageSelectedText));
}
// 変更後の値に応じて、画面表示を更新
- if (!String.IsNullOrEmpty(this.comboBoxLanguage.Text))
+ if (!string.IsNullOrEmpty(this.comboBoxLanguage.Text))
{
// 設定が存在しなければ基本的に自動生成されるのでそのまま使用
this.LoadCurrentValue(this.GetMediaWikiNeedCreate(this.config.Websites, this.comboBoxLanguage.Text));
this.groupBoxLanguage.Enabled = false;
// 現在の選択値を更新
- this.comboBoxLanguageSelectedText = String.Empty;
+ this.comboBoxLanguageSelectedText = string.Empty;
}
}
catch (Exception ex)
TextBox box = (TextBox)sender;
box.Text = StringUtils.DefaultString(box.Text).Trim();
int value;
- if (!String.IsNullOrEmpty(box.Text) && !int.TryParse(box.Text, out value))
+ if (!string.IsNullOrEmpty(box.Text) && !int.TryParse(box.Text, out value))
{
this.errorProvider.SetError(box, Resources.WarningMessageIgnoreNumericNamespace);
e.Cancel = true;
{
// 空か$1が含まれる文字列のみ許可
TextBox box = (TextBox)sender;
- if (!String.IsNullOrEmpty(box.Text) && !box.Text.Contains("$1"))
+ if (!string.IsNullOrEmpty(box.Text) && !box.Text.Contains("$1"))
{
this.errorProvider.SetError(box, Resources.WarningMessageUnformatedBracket);
e.Cancel = true;
// 言語コードは必須、またトリムして小文字に変換
string code = FormUtils.ToString(row.Cells["ColumnCode"]).Trim().ToLower();
row.Cells["ColumnCode"].Value = code;
- if (String.IsNullOrEmpty(code))
+ if (string.IsNullOrEmpty(code))
{
row.ErrorText = Resources.WarningMessageEmptyCodeColumn;
e.Cancel = true;
}
// 略称を設定する場合、呼称を必須とする
- if (!String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnShortName"]))
- && String.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnName"])))
+ if (!string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnShortName"]))
+ && string.IsNullOrWhiteSpace(FormUtils.ToString(row.Cells["ColumnName"])))
{
row.ErrorText = Resources.WarningMessageShortNameColumnOnly;
e.Cancel = true;
{
// 値が入ってないとかはガードしているはずだが、一応チェック
string code = FormUtils.ToString(this.dataGridViewLanguageName["ColumnCode", y]).Trim();
- if (!String.IsNullOrEmpty(code))
+ if (!string.IsNullOrEmpty(code))
{
Language.LanguageName name = new Language.LanguageName();
name.Name = FormUtils.ToString(this.dataGridViewLanguageName["ColumnName", y]).Trim();
site.DocumentationTemplates.Clear();
foreach (string s in StringUtils.DefaultString(this.textBoxDocumentationTemplate.Text).Split('\n'))
{
- if (!String.IsNullOrWhiteSpace(s))
+ if (!string.IsNullOrWhiteSpace(s))
{
site.DocumentationTemplates.Add(s.Trim());
}
site.HasLanguagePage = this.checkBoxHasLanguagePage.Checked;
// 以下、数値へのparseは事前にチェックしてあるので、ここではチェックしない
- if (!String.IsNullOrWhiteSpace(this.textBoxTemplateNamespace.Text))
+ if (!string.IsNullOrWhiteSpace(this.textBoxTemplateNamespace.Text))
{
int num = int.Parse(this.textBoxTemplateNamespace.Text);
if (site.TemplateNamespace != num)
}
}
- if (!String.IsNullOrWhiteSpace(this.textBoxCategoryNamespace.Text))
+ if (!string.IsNullOrWhiteSpace(this.textBoxCategoryNamespace.Text))
{
int num = int.Parse(this.textBoxCategoryNamespace.Text);
if (site.CategoryNamespace != num)
}
}
- if (!String.IsNullOrWhiteSpace(this.textBoxFileNamespace.Text))
+ if (!string.IsNullOrWhiteSpace(this.textBoxFileNamespace.Text))
{
int num = int.Parse(this.textBoxFileNamespace.Text);
if (site.FileNamespace != num)
/// <param name="e">発生したイベント。</param>
private void ResetErrorText_RowValidated(object sender, DataGridViewCellEventArgs e)
{
- ((DataGridView)sender).Rows[e.RowIndex].ErrorText = String.Empty;
+ ((DataGridView)sender).Rows[e.RowIndex].ErrorText = string.Empty;
}
/// <summary>
// 全行のエラーメッセージを解除
foreach (DataGridViewRow row in ((DataGridView)sender).Rows)
{
- row.ErrorText = String.Empty;
+ row.ErrorText = string.Empty;
}
}
/// <summary>
/// 取得日時が同じ場合にソートに用いる列名。
/// </summary>
- private static readonly string[] sortOrder = new string[] { "ColumnFromCode", "ColumnToCode", "ColumnFromTitle" };
+ private static readonly string[] SortOrder = new string[] { "ColumnFromCode", "ColumnToCode", "ColumnFromTitle" };
/// <summary>
/// 2行を比較し、一方が他方より小さいか、等しいか、大きいかを示す値を返します。
}
// 取得日時列が同じ場合、残りの列の昇順でソート
- foreach (string column in sortOrder)
+ foreach (string column in SortOrder)
{
- compare = String.Compare(
+ compare = string.Compare(
FormUtils.ToString(xrow.Cells[column]),
FormUtils.ToString(yrow.Cells[column]));
if (compare != 0)
/// <summary>
/// ログテキスト。
/// </summary>
- private string log = String.Empty;
+ private string log = string.Empty;
#endregion
public virtual void AddMessage(string format, params object[] args)
{
// 書式化してオーバーロードメソッドをコール
- this.AddMessage(String.Format(format, args));
+ this.AddMessage(string.Format(format, args));
}
/// <summary>
public virtual void AddResponse(string format, params object[] args)
{
// 書式化してオーバーロードメソッドをコール
- this.AddResponse(String.Format(format, args));
+ this.AddResponse(string.Format(format, args));
}
/// <summary>
public virtual void AddSeparator()
{
// この実装では、区切りは余分な空行で表す
- this.AddMessage(String.Empty);
+ this.AddMessage(string.Empty);
}
#endregion
protected void AddNewLineIfNotEndWithNewLine()
{
// ログが空以外で最後が改行ではない場合
- if (!String.IsNullOrEmpty(this.Log) && !this.Log.EndsWith(Environment.NewLine))
+ if (!string.IsNullOrEmpty(this.Log) && !this.Log.EndsWith(Environment.NewLine))
{
this.Log += Environment.NewLine;
}
/// <returns>冒頭部のテキスト。</returns>
protected virtual string CreateOpening(string title)
{
- string langPart = String.Empty;
+ string langPart = string.Empty;
IElement langLink = this.GetLanguageLink();
if (langLink != null)
{
}
string langBody = this.To.FormatLang(this.From.Language.Code, title);
- if (String.IsNullOrEmpty(langBody))
+ if (string.IsNullOrEmpty(langBody))
{
langBody = title;
}
MediaWikiLink link = new MediaWikiLink();
link.Title = page.Title;
link.Interwiki = this.From.Language.Code;
- return "\n\n" + link.ToString() + "\n" + String.Format(
+ return "\n\n" + link.ToString() + "\n" + string.Format(
Resources.ArticleFooter,
FormUtils.ApplicationName(),
this.From.Language.Code,
page.Title,
- page.Timestamp.HasValue ? page.Timestamp.Value.ToString("U") : String.Empty) + "\n";
+ page.Timestamp.HasValue ? page.Timestamp.Value.ToString("U") : string.Empty) + "\n";
}
#endregion
if (parent.Title.StartsWith(title))
{
// サブページ（親）の場合、変換してもしょうがないのでセクションだけチェックして終了
- if (!String.IsNullOrEmpty(link.Section))
+ if (!string.IsNullOrEmpty(link.Section))
{
link.Section = this.ReplaceLinkSection(link.Section);
link.ParsedString = null;
link.Title = title;
}
- else if (!String.IsNullOrEmpty(link.Interwiki))
+ else if (!string.IsNullOrEmpty(link.Interwiki))
{
// 言語間リンク・姉妹プロジェクトへのリンクの場合、変換対象外とする
// ただし、先頭が : でない、翻訳先言語への言語間リンクだけは削除
{
// 記事自体が存在しない（赤リンク）場合、リンクはそのまま
}
- else if (interWiki == String.Empty)
+ else if (interWiki == string.Empty)
{
// 言語間リンクが存在しない場合、可能なら{{仮リンク}}に置き換え
- if (!String.IsNullOrEmpty(this.To.LinkInterwikiFormat))
+ if (!string.IsNullOrEmpty(this.To.LinkInterwikiFormat))
{
return this.ReplaceLinkLinkInterwiki(link);
}
}
// セクション部分（[[#関連項目]]とか）を変換
- if (!String.IsNullOrEmpty(link.Section))
+ if (!string.IsNullOrEmpty(link.Section))
{
link.Section = this.ReplaceLinkSection(link.Section);
}
// 記事自体が存在しない（赤リンク）場合、リンクはそのまま
return template;
}
- else if (interWiki == String.Empty)
+ else if (interWiki == string.Empty)
{
// 言語間リンクが存在しない場合、[[:en:Template:xxx]]みたいな普通のリンクに置換
// おまけで、元のテンプレートの状態をコメントでつける
if (this.ItemTable.TryGetValue(decodedTitle, out item))
{
// 存在する場合はその値を使用
- if (!String.IsNullOrWhiteSpace(item.Alias))
+ if (!string.IsNullOrWhiteSpace(item.Alias))
{
// リダイレクトがあれば、そのメッセージも表示
this.Logger.AddAlias(new MediaWikiLink(item.Alias));
}
- if (!String.IsNullOrEmpty(item.Word))
+ if (!string.IsNullOrEmpty(item.Word))
{
this.Logger.AddDestination(new MediaWikiLink(item.Word), true);
return item.Word;
else
{
this.Logger.AddDestination(new TextElement(Resources.LogMessageInterWikiNotFound), true);
- return String.Empty;
+ return string.Empty;
}
}
else
{
// 見つからない場合は空
- item.Word = String.Empty;
+ item.Word = string.Empty;
this.Logger.AddDestination(new TextElement(Resources.LogMessageInterWikiNotFound));
}
// 言語コード等も特に無く、かつセクションが指定されている場合
// （記事名もセクションも指定されていない・・・というケースもありえるが、
// その場合他に指定できるものも思いつかないので通す）
- return String.IsNullOrEmpty(link.Title)
- || (link.Title == parent && String.IsNullOrEmpty(link.Interwiki) && !String.IsNullOrEmpty(link.Section));
+ return string.IsNullOrEmpty(link.Title)
+ || (link.Title == parent && string.IsNullOrEmpty(link.Interwiki) && !string.IsNullOrEmpty(link.Section));
}
/// <summary>
// 記事自体が存在しない（赤リンク）場合、リンクはそのまま
return link;
}
- else if (interWiki == String.Empty)
+ else if (interWiki == string.Empty)
{
// 言語間リンクが存在しない場合、コメントで元の文字列を保存した後
// [[:en:xxx]]みたいな形式に置換。また | 以降は削除する
// ※ 渡されたlinkをそのまま使わないのは、余計なゴミが含まれる可能性があるため
MediaWikiLink title = new MediaWikiLink { Title = link.Title, Section = link.Section };
string langTitle = title.GetLinkString();
- if (!String.IsNullOrEmpty(title.Section))
+ if (!string.IsNullOrEmpty(title.Section))
{
// 変換先言語版のセクションは、セクションの変換を通したものにする
title.Section = this.ReplaceLinkSection(title.Section);
// 略称を取得
IElement shortName = null;
- if (!String.IsNullOrEmpty(name.ShortName))
+ if (!string.IsNullOrEmpty(name.ShortName))
{
shortName = new TextElement(name.ShortName);
}
{
// 確認ダイアログを表示
if (MessageBox.Show(
- String.Format(Resources.QuestionMessageArticleExisted, interwiki),
+ string.Format(Resources.QuestionMessageArticleExisted, interwiki),
Resources.QuestionTitle,
MessageBoxButtons.YesNo,
MessageBoxIcon.Question)
/// <summary>
/// 変換後テキスト。
/// </summary>
- private string text = String.Empty;
+ private string text = string.Empty;
/// <summary>
/// ログテキスト生成用ロガー。
{
// サーバー接続チェック
string host = new Uri(this.From.Location).Host;
- if (!String.IsNullOrEmpty(host) && !Settings.Default.IgnoreError)
+ if (!string.IsNullOrEmpty(host) && !Settings.Default.IgnoreError)
{
if (!this.Ping(host))
{
this.Logger.Clear();
this.StatusManager.Clear();
this.Stopwatch.Reset();
- this.Text = String.Empty;
+ this.Text = string.Empty;
this.CancellationPending = false;
this.From.WebProxy.Referer = null;
this.To.WebProxy.Referer = null;
private void SetLanguageNameLabel(Label label, Website site)
{
// ラベルを初期化
- label.Text = String.Empty;
+ label.Text = string.Empty;
if (site == null)
{
return;
private void ButtonSaveDirectory_Click(object sender, EventArgs e)
{
// フォルダ名が入力されている場合、それを初期位置に設定
- if (!String.IsNullOrEmpty(this.textBoxSaveDirectory.Text))
+ if (!string.IsNullOrEmpty(this.textBoxSaveDirectory.Text))
{
this.folderBrowserDialogSaveDirectory.SelectedPath = this.textBoxSaveDirectory.Text;
}
private void ButtonRun_Click(object sender, EventArgs e)
{
// フォーム入力値をチェック
- if (String.IsNullOrWhiteSpace(this.comboBoxSource.Text))
+ if (string.IsNullOrWhiteSpace(this.comboBoxSource.Text))
{
FormUtils.WarningDialog(Resources.WarningMessageNotSelectedSource);
this.comboBoxSource.Focus();
return;
}
- else if (String.IsNullOrWhiteSpace(this.comboBoxTarget.Text))
+ else if (string.IsNullOrWhiteSpace(this.comboBoxTarget.Text))
{
FormUtils.WarningDialog(Resources.WarningMessageNotSelectedTarget);
this.comboBoxTarget.Focus();
return;
}
- else if (!String.IsNullOrWhiteSpace(this.comboBoxSource.Text)
+ else if (!string.IsNullOrWhiteSpace(this.comboBoxSource.Text)
&& this.comboBoxSource.Text == this.comboBoxTarget.Text)
{
FormUtils.WarningDialog(Resources.WarningMessageEqualsSourceAndTarget);
this.comboBoxTarget.Focus();
return;
}
- else if (String.IsNullOrWhiteSpace(this.textBoxSaveDirectory.Text))
+ else if (string.IsNullOrWhiteSpace(this.textBoxSaveDirectory.Text))
{
FormUtils.WarningDialog(Resources.WarningMessageEmptySaveDirectory);
this.textBoxSaveDirectory.Focus();
this.textBoxSaveDirectory.Focus();
return;
}
- else if (String.IsNullOrWhiteSpace(this.textBoxArticle.Text))
+ else if (string.IsNullOrWhiteSpace(this.textBoxArticle.Text))
{
FormUtils.WarningDialog(Resources.WarningMessageEmptyArticle);
this.textBoxArticle.Focus();
// 表示領域を初期化、処理時間更新用にタイマーを起動
this.textBoxLog.Clear();
this.logLength = 0;
- this.textBoxLog.AppendText(String.Format(Resources.LogMessageStart, FormUtils.ApplicationName(), DateTime.Now));
- this.toolStripStatusLabelStopwatch.Text = String.Format(Resources.ElapsedTime, TimeSpan.Zero);
+ this.textBoxLog.AppendText(string.Format(Resources.LogMessageStart, FormUtils.ApplicationName(), DateTime.Now));
+ this.toolStripStatusLabelStopwatch.Text = string.Format(Resources.ElapsedTime, TimeSpan.Zero);
this.timerStatusStopwatch.Start();
// バックグラウンド処理を実行
{
// 想定外の通信エラー（↓とまとめてもよいが、こちらはサーバーの状況などで発生しやすいので）
WebException ex = (WebException)e.Error;
- this.textBoxLog.AppendText(Environment.NewLine + String.Format(Resources.ErrorMessageConnectionFailed, ex.Message) + Environment.NewLine);
+ this.textBoxLog.AppendText(Environment.NewLine + string.Format(Resources.ErrorMessageConnectionFailed, ex.Message) + Environment.NewLine);
if (ex.Response != null)
{
// 出せるならエラーとなったURLも出力
- this.textBoxLog.AppendText(Resources.RightArrow + " " + String.Format(Resources.LogMessageErrorURL, ex.Response.ResponseUri) + Environment.NewLine);
+ this.textBoxLog.AppendText(Resources.RightArrow + " " + string.Format(Resources.LogMessageErrorURL, ex.Response.ResponseUri) + Environment.NewLine);
}
}
else
{
// 想定外のエラー
- this.textBoxLog.AppendText(Environment.NewLine + String.Format(Resources.ErrorMessageDevelopmentError, e.Error.Message, e.Error.StackTrace) + Environment.NewLine);
+ this.textBoxLog.AppendText(Environment.NewLine + string.Format(Resources.ErrorMessageDevelopmentError, e.Error.Message, e.Error.StackTrace) + Environment.NewLine);
}
}
else
try
{
File.WriteAllText(Path.Combine(this.textBoxSaveDirectory.Text, fileName), this.translator.Text);
- this.textBoxLog.AppendText(String.Format(Resources.LogMessageEnd, fileName, logName));
+ this.textBoxLog.AppendText(string.Format(Resources.LogMessageEnd, fileName, logName));
}
catch (Exception ex)
{
- this.textBoxLog.AppendText(String.Format(Resources.LogMessageFileSaveFailed, Path.Combine(this.textBoxSaveDirectory.Text, fileName), ex.Message));
- this.textBoxLog.AppendText(String.Format(Resources.LogMessageStop, logName));
+ this.textBoxLog.AppendText(string.Format(Resources.LogMessageFileSaveFailed, Path.Combine(this.textBoxSaveDirectory.Text, fileName), ex.Message));
+ this.textBoxLog.AppendText(string.Format(Resources.LogMessageStop, logName));
}
}
else
{
- this.textBoxLog.AppendText(String.Format(Resources.LogMessageStop, logName));
+ this.textBoxLog.AppendText(string.Format(Resources.LogMessageStop, logName));
}
// ログを出力
}
catch (Exception ex)
{
- this.textBoxLog.AppendText(String.Format(Resources.LogMessageFileSaveFailed, Path.Combine(this.textBoxSaveDirectory.Text, logName), ex.Message));
+ this.textBoxLog.AppendText(string.Format(Resources.LogMessageFileSaveFailed, Path.Combine(this.textBoxSaveDirectory.Text, logName), ex.Message));
}
}
}
if (this.translator != null)
{
// 処理時間をステータスバーに反映
- this.toolStripStatusLabelStopwatch.Text = String.Format(Resources.ElapsedTime, this.translator.Stopwatch.Elapsed);
+ this.toolStripStatusLabelStopwatch.Text = string.Format(Resources.ElapsedTime, this.translator.Stopwatch.Elapsed);
}
}
private void ToolStripMenuItemAuto_Click(object sender, EventArgs e)
{
// 表示言語を空欄に設定し再起動する
- this.ChangeCultureAndRestart(String.Empty);
+ this.ChangeCultureAndRestart(string.Empty);
}
/// <summary>
{
// ユーザーごと・または初期設定用の設定ファイルを読み込み
string path = FormUtils.SearchUserAppData(file, Settings.Default.ConfigurationCompatible);
- if (String.IsNullOrEmpty(path))
+ if (string.IsNullOrEmpty(path))
{
// どこにも無い場合は例外を投げる
throw new FileNotFoundException(file + " is not found");
public void Save()
{
// このインスタンスとファイルが紐付いていない場合、実行不可
- if (String.IsNullOrWhiteSpace(this.File))
+ if (string.IsNullOrWhiteSpace(this.File))
{
throw new InvalidOperationException("file is empty");
}
{
get
{
- if (String.IsNullOrWhiteSpace(this.bracket))
+ if (string.IsNullOrWhiteSpace(this.bracket))
{
return Settings.Default.Bracket;
}
item.Word = itemElement.GetAttribute("To");
item.Alias = itemElement.GetAttribute("Redirect");
string timestamp = itemElement.GetAttribute("Timestamp");
- if (!String.IsNullOrEmpty(timestamp))
+ if (!string.IsNullOrEmpty(timestamp))
{
item.Timestamp = DateTime.Parse(timestamp);
writer.WriteStartElement("Item");
writer.WriteAttributeString("From", item.Key);
writer.WriteAttributeString("To", item.Value.Word);
- if (!String.IsNullOrWhiteSpace(item.Value.Alias))
+ if (!string.IsNullOrWhiteSpace(item.Value.Alias))
{
writer.WriteAttributeString("Redirect", item.Value.Alias);
}
/// <remarks>大文字小文字は区別しない。</remarks>
public string GetWord(string word)
{
- if (String.IsNullOrEmpty(this.From) || String.IsNullOrEmpty(this.To))
+ if (string.IsNullOrEmpty(this.From) || string.IsNullOrEmpty(this.To))
{
throw new InvalidOperationException("empty from or to");
}
{
// 入力値確認、空の場合は即終了
result = null;
- if (String.IsNullOrEmpty(s))
+ if (string.IsNullOrEmpty(s))
{
return false;
}
}
// 言語コード・他プロジェクトコードの付加
- if (!String.IsNullOrEmpty(this.Interwiki))
+ if (!string.IsNullOrEmpty(this.Interwiki))
{
b.Append(this.Interwiki);
b.Append(':');
}
// 記事名の付加
- if (!String.IsNullOrEmpty(this.Title))
+ if (!string.IsNullOrEmpty(this.Title))
{
b.Append(this.Title);
}
// 子パーサーが解放済みの場合Dispose済みで処理不可
throw new ObjectDisposedException(this.GetType().Name);
}
- else if (String.IsNullOrEmpty(s))
+ else if (string.IsNullOrEmpty(s))
{
// 入力値が空の場合は即終了
return false;
format = Settings.Default.MediaWikiRedirect;
}
- if (!String.IsNullOrEmpty(format)
+ if (!string.IsNullOrEmpty(format)
&& lower.StartsWith(format.ToLower()))
{
// "#REDIRECT "の部分をカットして後ろの[[～]]の部分のリンクを解析
}
// 言語コード・他プロジェクトコードの付加
- if (!String.IsNullOrEmpty(this.Interwiki))
+ if (!string.IsNullOrEmpty(this.Interwiki))
{
b.Append(this.Interwiki);
b.Append(':');
}
// テンプレート名の付加
- if (!String.IsNullOrEmpty(this.Title))
+ if (!string.IsNullOrEmpty(this.Title))
{
b.Append(this.Title);
}
// 終了条件でループを抜けていない場合、解析失敗
// テンプレート名が無い場合も解析失敗
// ※ 内部リンクの場合ありえるが、テンプレートの場合2012年現在無いと認識されない
- if (lastIndex < 0 || String.IsNullOrWhiteSpace(article.ToString()))
+ if (lastIndex < 0 || string.IsNullOrWhiteSpace(article.ToString()))
{
return false;
}
b.Append(MediaWikiVariable.DelimiterStart);
// 変数
- if (!String.IsNullOrEmpty(this.Variable))
+ if (!string.IsNullOrEmpty(this.Variable))
{
b.Append(this.Variable);
}
/// <remarks>特に表示言語が指定されていない場合は何もしない。</remarks>
public static void LoadSelectedCulture()
{
- if (!String.IsNullOrWhiteSpace(Settings.Default.LastSelectedLanguage))
+ if (!string.IsNullOrWhiteSpace(Settings.Default.LastSelectedLanguage))
{
try
{
【ファイル】 wptscs121.msi, wptscs121.zip, wptscs121-src.zip
【作成月日】 2012/x/xx
【制 作 者】 Honeplus
-【動作環境】 Windows XP/Vista/7 での動作を確認。要.NET Framework 4.0 Client Profile
+【動作環境】 Windows 8 での動作を確認。要.NET Framework 4.0 Client Profile
【配布形態】 修正BSDライセンス
【HomePage】 http://sourceforge.jp/projects/wptscs/
=====================================================================
アプリケーション上で設定した内容は、上記設定ファイルには反映されません。
ユーザーごとのフォルダに出力されます。
設定ファイルを直接修正、または削除して初期値に戻したい場合は、
-下記のようなパスにあるファイルを更新してください（以下はVistaの例）。
+下記のようなパスにあるファイルを更新してください（以下はWindows 8の例）。
C:\Users\[ユーザー名]\AppData\Roaming\Honememo\Wikipedia 翻訳支援ツール\[バージョン番号]\config.xml
C:\Users\[ユーザー名]\AppData\Local\Honememo\wptscs.exe_[～]\[バージョン番号]\user.config
・ソースについて
-wptscs120-src.zip としてソースファイル一式を配布しています。
-開発環境はVisual C# 2010 Expressです。その他外部ツールとしてテスト自動化ツールのNUnitと、
+wptscs121-src.zip としてソースファイル一式を配布しています。
+開発環境はVisual C# 2012 Expressです。その他外部ツールとして
コーディングスタイルチェック用のStyleCopを使用しています。
また、インストーラの作成にはWiX並びにWindows SDKを使用しています。
このプログラムの変更・再配布・流用はご自由にどうぞ。
-また、ソース中にNUnitのテストデータとしてWikipedia/Wiktionaryより取得したXMLを同梱しています。
+また、ソース中にテストデータとしてWikipedia/Wiktionaryより取得したXMLを同梱しています。
これらファイル内の著作物の扱いについては、Wikipedia/Wiktionaryのライセンスに従ってください。
・仕様上の制限
-プログラム上の問題により、記事名がピリオドで終わるページは処理できません。
+ã\83\97ã\83ã\82°ã\83©ã\83 ä¸\8aã\81®å\95\8fé¡\8cã\81«ã\82\88ã\82\8aã\80\81è¨\98äº\8bå\90\8dã\81\8cã\83\94ã\83ªã\82ªã\83\89ã\82\84ã\83\8fã\83\86ã\83\8aã\81§çµ\82ã\82\8fã\82\8bã\83\9aã\83¼ã\82¸ã\81¯å\87¦ç\90\86ã\81§ã\81\8dã\81¾ã\81\9bã\82\93ã\80\82
（例、[[Vulcan Inc.]]）
キャッシュの一覧で一度に大量の項目を削除すると、フリーズしたかのように時間がかかります。
{
// アプリ設定値を確認
string ua = Settings.Default.UserAgent;
- if (!String.IsNullOrEmpty(ua))
+ if (!string.IsNullOrEmpty(ua))
{
return ua;
}
// いずれも存在しない場合は、デフォルトの値を生成して返す
Version ver = Assembly.GetExecutingAssembly().GetName().Version;
- return String.Format(Settings.Default.DefaultUserAgent, ver.Major, ver.Minor);
+ return string.Format(Settings.Default.DefaultUserAgent, ver.Major, ver.Minor);
}
set
{
// アプリ設定値を確認
string r = Settings.Default.Referer;
- if (String.IsNullOrEmpty(r))
+ if (string.IsNullOrEmpty(r))
{
// 存在しない場合、このプロパティの値を返す
r = this.referer;
// ビルド番号・リビジョンは無視
// ※例外なし。もし万が一発生する場合はそのまま投げる
Version ver = Assembly.GetExecutingAssembly().GetName().Version;
- return String.Format(Resources.ApplicationName, ver.Major, ver.Minor);
+ return string.Format(Resources.ApplicationName, ver.Major, ver.Minor);
}
/// <summary>
}
// 可能であれば、旧バージョンの UserAppDataPath を探索
- if (!String.IsNullOrEmpty(compatible))
+ if (!string.IsNullOrEmpty(compatible))
{
// ファイルが見つかるまで探索
foreach (string dir in FormUtils.GetCompatibleUserAppDataPaths(compatible))
}
// 可能であれば、旧バージョンの UserAppDataPath を探索
- if (!String.IsNullOrEmpty(compatible))
+ if (!string.IsNullOrEmpty(compatible))
{
// 各ディレクトリのファイル名を取得
foreach (string dir in FormUtils.GetCompatibleUserAppDataPaths(compatible))
/// <returns>渡されたセルの<see cref="DataGridViewCell.Value"/>を<see cref="Object.ToString"/>した結果。<c>null</c>の場合には空の文字列。</returns>
public static string ToString(DataGridViewCell obj)
{
- return FormUtils.ToString(obj, String.Empty);
+ return FormUtils.ToString(obj, string.Empty);
}
/// <summary>
public static void InformationDialog(string format, params object[] args)
{
// オーバーロードメソッドをコール
- FormUtils.InformationDialog(String.Format(format, args));
+ FormUtils.InformationDialog(string.Format(format, args));
}
/// <summary>
public static void WarningDialog(string format, params object[] args)
{
// オーバーロードメソッドをコール
- FormUtils.WarningDialog(String.Format(format, args));
+ FormUtils.WarningDialog(string.Format(format, args));
}
/// <summary>
public static void ErrorDialog(string format, params object[] args)
{
// オーバーロードメソッドをコール
- FormUtils.ErrorDialog(String.Format(format, args));
+ FormUtils.ErrorDialog(string.Format(format, args));
}
#endregion
{
foreach (DataGridViewCell cell in row.Cells)
{
- if (!String.IsNullOrEmpty(FormUtils.ToString(cell)))
+ if (!string.IsNullOrEmpty(FormUtils.ToString(cell)))
{
return false;
}
// という構成のはずなので、一つ上のフォルダから自分より前のフォルダを探索
List<string> paths = new List<string>();
string parent = Path.GetDirectoryName(Application.UserAppDataPath);
- if (!String.IsNullOrEmpty(parent))
+ if (!string.IsNullOrEmpty(parent))
{
// 現在のバージョンのフォルダ名
string now = Path.GetFileName(Application.UserAppDataPath);
{
// 親で初期化していないのは、languageのnullチェックの前にnull参照でエラーになってしまうから
this.Language = language;
- this.Location = String.Format(Settings.Default.WikipediaLocation, language.Code);
+ this.Location = string.Format(Settings.Default.WikipediaLocation, language.Code);
}
/// <summary>
{
get
{
- if (String.IsNullOrEmpty(this.metaApi))
+ if (string.IsNullOrEmpty(this.metaApi))
{
return Settings.Default.MediaWikiMetaApi;
}
{
get
{
- if (String.IsNullOrEmpty(this.exportPath))
+ if (string.IsNullOrEmpty(this.exportPath))
{
return Settings.Default.MediaWikiExportPath;
}
{
get
{
- if (String.IsNullOrEmpty(this.redirect))
+ if (string.IsNullOrEmpty(this.redirect))
{
return Settings.Default.MediaWikiRedirect;
}
/// <returns>書式化した文字列。<see cref="LinkInterwikiFormat"/>が未設定の場合<c>null</c>。</returns>
public string FormatLinkInterwiki(string title, string lang, string langTitle, string label)
{
- if (String.IsNullOrEmpty(this.LinkInterwikiFormat))
+ if (string.IsNullOrEmpty(this.LinkInterwikiFormat))
{
return null;
}
/// </remarks>
public string FormatLang(string lang, string text)
{
- if (String.IsNullOrEmpty(this.LangFormat))
+ if (string.IsNullOrEmpty(this.LangFormat))
{
return null;
}
writer.WriteElementString("Redirect", this.redirect);
writer.WriteElementString(
"TemplateNamespace",
- this.templateNamespace.HasValue ? this.templateNamespace.ToString() : String.Empty);
+ this.templateNamespace.HasValue ? this.templateNamespace.ToString() : string.Empty);
writer.WriteElementString(
"CategoryNamespace",
- this.templateNamespace.HasValue ? this.categoryNamespace.ToString() : String.Empty);
+ this.templateNamespace.HasValue ? this.categoryNamespace.ToString() : string.Empty);
writer.WriteElementString(
"FileNamespace",
- this.templateNamespace.HasValue ? this.fileNamespace.ToString() : String.Empty);
+ this.templateNamespace.HasValue ? this.fileNamespace.ToString() : string.Empty);
// システム定義変数
writer.WriteStartElement("MagicWords");
{
try
{
- int id = Decimal.ToInt16(Decimal.Parse(namespaceElement.GetAttribute("id")));
+ int id = decimal.ToInt16(decimal.Parse(namespaceElement.GetAttribute("id")));
IgnoreCaseSet values = new IgnoreCaseSet();
values.Add(namespaceElement.InnerText);
namespaces[id] = values;
// あれば標準名も設定
string canonical = namespaceElement.GetAttribute("canonical");
- if (!String.IsNullOrEmpty(canonical))
+ if (!string.IsNullOrEmpty(canonical))
{
values.Add(canonical);
}
{
try
{
- int id = Decimal.ToInt16(Decimal.Parse(namespaceElement.GetAttribute("id")));
+ int id = decimal.ToInt16(decimal.Parse(namespaceElement.GetAttribute("id")));
ISet<string> values = new HashSet<string>();
if (namespaces.ContainsKey(id))
{
if (interwikiElement != null)
{
string prefix = interwikiElement.GetAttribute("prefix");
- if (!String.IsNullOrWhiteSpace(prefix))
+ if (!string.IsNullOrWhiteSpace(prefix))
{
interwikiPrefixs.Add(prefix);
}
this.redirect = null;
// 本文格納のタイミングでリダイレクトページ（#REDIRECT等）かを判定
- if (!String.IsNullOrEmpty(base.Text))
+ if (!string.IsNullOrEmpty(base.Text))
{
IElement element;
using (MediaWikiRedirectParser parser = new MediaWikiRedirectParser(this.Website))
// インラインでなさそうな場合、解説記事名を確認
string subtitle = ObjectUtils.ToString(template.PipeTexts.ElementAtOrDefault(0));
- if (String.IsNullOrWhiteSpace(subtitle) || subtitle.Contains('='))
+ if (string.IsNullOrWhiteSpace(subtitle) || subtitle.Contains('='))
{
// 指定されていない場合はデフォルトのページを探索
subtitle = this.Website.DocumentationTemplateDefaultPage;
}
- if (String.IsNullOrEmpty(subtitle))
+ if (string.IsNullOrEmpty(subtitle))
{
return null;
}
// 親記事名と子記事名（あれば）を結合して完了
title = parent;
- if (!String.IsNullOrEmpty(subtitle))
+ if (!string.IsNullOrEmpty(subtitle))
{
title += "/" + subtitle;
}
// 補完する必要がある場合、名前空間のプレフィックス（Template等）を取得
string prefix = this.GetTemplatePrefix();
- if (String.IsNullOrEmpty(prefix))
+ if (string.IsNullOrEmpty(prefix))
{
// 名前空間の設定が存在しない場合、何も出来ないため終了
return template.Title;
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>bin\Debug\wptscs.XML</DocumentationFile>
+ <RunCodeAnalysis>false</RunCodeAnalysis>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
- <Import Project="$(ProgramFiles)\MSBuild\Microsoft\StyleCop\v4.4\Microsoft.StyleCop.Targets" />
+ <Import Project="$(ProgramFiles)\MSBuild\StyleCop\v4.7\StyleCop.Targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
using System;
using System.Collections.Generic;
using Honememo.Parsers;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// Loggerのテストクラスです。
+ /// <see cref="Logger"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class LoggerTest
{
#region private変数
/// <summary>
/// テストの前処理。
/// </summary>
- [TestFixtureSetUp]
- public void SetUpBeforeClass()
+ [TestInitialize]
+ public void SetUp()
{
// ロガーの処理結果はカルチャーにより変化するため、ja-JPを明示的に設定する
this.backupCulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
/// <summary>
/// テストの後処理。
/// </summary>
- [TestFixtureTearDown]
- public void TearDownAfterClass()
+ [TestCleanup]
+ public void TearDown()
{
// カルチャーを元に戻す
System.Threading.Thread.CurrentThread.CurrentUICulture = this.backupCulture;
/// <summary>
/// Logプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestLog()
{
// 初期状態は空
LoggerMock logger = new LoggerMock();
- Assert.IsEmpty(logger.Log);
+ Assert.AreEqual(string.Empty, logger.Log);
// null設定時は空白が設定されること、それ以外はそのまま
logger.Log = null;
- Assert.IsEmpty(logger.Log);
+ Assert.AreEqual(string.Empty, logger.Log);
logger.Log = "test";
Assert.AreEqual("test", logger.Log);
/// <summary>
/// AddMessageメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddMessage()
{
LoggerMock logger = new LoggerMock();
// 通常は一行が出力される
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddMessage("1st string");
Assert.AreEqual("1st string" + Environment.NewLine, logger.ToString());
Assert.AreEqual(1, logger.Count);
/// <summary>
/// AddResponseメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddResponse()
{
LoggerMock logger = new LoggerMock();
// 通常は一行が出力される
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddResponse("1st string");
Assert.AreEqual("→ 1st string" + Environment.NewLine, logger.ToString());
Assert.AreEqual(1, logger.Count);
/// <summary>
/// AddErrorメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddError()
{
LoggerMock logger = new LoggerMock();
// 通常は例外内のメッセージだけが出力される
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddError(new ArgumentException("this is exception"));
Assert.AreEqual("→ this is exception" + Environment.NewLine, logger.ToString());
Assert.AreEqual(1, logger.Count);
/// <summary>
/// AddSeparatorメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddSeparator()
{
LoggerMock logger = new LoggerMock();
// 空行が出力される
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddSeparator();
Assert.AreEqual(Environment.NewLine, logger.ToString());
Assert.AreEqual(1, logger.Count);
/// <summary>
/// AddSourceメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddSource()
{
LoggerMock logger = new LoggerMock();
// 直前のログが改行されていない場合、改行して出力
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddSource(new TextElement("1st string"));
Assert.AreEqual("1st string → ", logger.ToString());
Assert.AreEqual(1, logger.Count);
/// <summary>
/// AddAliasメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddAlias()
{
LoggerMock logger = new LoggerMock();
// 矢印付きの出力のみ
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddAlias(new TextElement("1st string"));
Assert.AreEqual("1st string → ", logger.ToString());
Assert.AreEqual(1, logger.Count);
/// <summary>
/// AddDestinationメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddDestination()
{
LoggerMock logger = new LoggerMock();
// 変換先の出力と改行、キャッシュの指定があればそのコメント
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddDestination(new TextElement("1st string"));
Assert.AreEqual("1st string" + Environment.NewLine, logger.ToString());
Assert.AreEqual(1, logger.Count);
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
LoggerMock logger = new LoggerMock();
// ログテキストとして格納している内容がそのまま出力される
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.Log = "テストログ";
Assert.AreEqual("テストログ", logger.ToString());
}
/// <summary>
/// Clearメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestClear()
{
LoggerMock logger = new LoggerMock();
logger.Log = "テストログ";
Assert.AreEqual("テストログ", logger.ToString());
logger.Clear();
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
}
#endregion
using System.Collections.Generic;
using Honememo.Parsers;
using Honememo.Wptscs.Parsers;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// MediaWikiLoggerのテストクラスです。
+ /// <see cref="MediaWikiLogger"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class MediaWikiLoggerTest
{
#region private変数
/// <summary>
/// テストの前処理。
/// </summary>
- [TestFixtureSetUp]
- public void SetUpBeforeClass()
+ [TestInitialize]
+ public void SetUp()
{
// ロガーの処理結果はカルチャーにより変化するため、ja-JPを明示的に設定する
this.backupCulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
/// <summary>
/// テストの後処理。
/// </summary>
- [TestFixtureTearDown]
- public void TearDownAfterClass()
+ [TestCleanup]
+ public void TearDown()
{
// カルチャーを元に戻す
System.Threading.Thread.CurrentThread.CurrentUICulture = this.backupCulture;
/// <summary>
/// AddSourceメソッドテストケース。
/// </summary>
- [Test]
public void TestAddSource()
{
LoggerMock logger = new LoggerMock();
Logger diff = new Logger();
// 通常の要素の場合、普通のロガーと同様に処理される
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddSource(new TextElement("1st string"));
diff.AddSource(new TextElement("1st string"));
Assert.AreEqual(diff.ToString(), logger.ToString());
/// <summary>
/// AddAliasメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddAlias()
{
LoggerMock logger = new LoggerMock();
// リダイレクトとして出力
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddAlias(new TextElement("1st string"));
Assert.AreEqual("リダイレクト 1st string → ", logger.ToString());
Assert.AreEqual(1, logger.Count);
/// <summary>
/// AddDestinationメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestAddDestination()
{
LoggerMock logger = new LoggerMock();
Logger diff = new Logger();
// 通常の要素の場合、普通のロガーと同様に処理される
- Assert.IsEmpty(logger.ToString());
+ Assert.AreEqual(string.Empty, logger.ToString());
logger.AddDestination(new TextElement("1st string"));
diff.AddDestination(new TextElement("1st string"));
Assert.AreEqual(diff.ToString(), logger.ToString());
using Honememo.Wptscs.Parsers;
using Honememo.Wptscs.Utilities;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiTranslator"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiTranslatorTest
{
#region 定数
/// <summary>
/// テスト結果が格納されているフォルダパス。
/// </summary>
- private static readonly string resultDir = Path.Combine(MockFactory.TestMediaWikiDir, "result");
+ private static readonly string ResultDir = Path.Combine(MockFactory.TestMediaWikiDir, "result");
#endregion
/// <summary>
/// テストの前処理。
/// </summary>
- [TestFixtureSetUp]
- public void SetUpBeforeClass()
+ [TestInitialize]
+ public void SetUp()
{
// ロガーの処理結果はカルチャーにより変化するため、ja-JPを明示的に設定する
this.backupCulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
/// <summary>
/// テストの後処理。
/// </summary>
- [TestFixtureTearDown]
- public void TearDownAfterClass()
+ [TestCleanup]
+ public void TearDown()
{
// カルチャーを元に戻す
System.Threading.Thread.CurrentThread.CurrentUICulture = this.backupCulture;
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceLink"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceLink()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceLink"/>メソッドテストケース（サブページ）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceLinkSubpage()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceLink"/>メソッドテストケース（カテゴリ）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceLinkCategory()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceLink"/>メソッドテストケース（ファイル）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceLinkFile()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceLink"/>メソッドテストケース（仮リンク）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceLinkLinkInterwiki()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceTemplate"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceTemplate()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceTemplate"/>メソッドテストケース（入れ子）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceTemplateNested()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceHeading"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceHeading()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.ReplaceHeading"/>メソッドテストケース（入れ子）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceHeadingNested()
{
TestMediaWikiTranslator translator = new TestMediaWikiTranslator();
/// <summary>
/// <see cref="MediaWikiTranslator.CreateOpening"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCreateOpening()
{
// From, Toの設定に応じて変換後記事の冒頭部を作り出す
/// <summary>
/// テストデータを用い、Runを通しで実行するテストケース。基本動作。
/// </summary>
- [Test]
+ [TestMethod]
public void TestExampleIgnoreHeading()
{
MockFactory mock = new MockFactory();
// テストデータの変換結果を期待される結果と比較する
// バージョン表記部分は毎回変化するため、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "example_定型句なし.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.xx", "<!-- " + FormUtils.ApplicationName()),
+ File.ReadAllText(Path.Combine(ResultDir, "example_定型句なし.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.xx", "<!-- " + FormUtils.ApplicationName()),
translator.Text);
// テストデータの変換ログを期待されるログと比較する
// 1行目のパスが一致しないので、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "example_定型句なし.log")).Replace("file:///xxx/Data/MediaWiki/en/", from.Location),
+ File.ReadAllText(Path.Combine(ResultDir, "example_定型句なし.log")).Replace("file:///xxx/Data/MediaWiki/en/", from.Location),
translator.Log);
}
/// テストデータを用い、Runを通しで実行するテストケース。基本動作見出しの変換含む。
/// </summary>
/// <remarks>C++/CLI版の0.73までと同等の動作。</remarks>
- [Test]
+ [TestMethod]
public void TestExample()
{
MockFactory mock = new MockFactory();
// テストデータの変換結果を期待される結果と比較する
// バージョン表記部分は毎回変化するため、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "example.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.73", "<!-- " + FormUtils.ApplicationName()),
+ File.ReadAllText(Path.Combine(ResultDir, "example.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.73", "<!-- " + FormUtils.ApplicationName()),
translator.Text);
// テストデータの変換ログを期待されるログと比較する
// 1行目のパスが一致しないので、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "example.log")).Replace("http://en.wikipedia.org", from.Location),
+ File.ReadAllText(Path.Combine(ResultDir, "example.log")).Replace("http://en.wikipedia.org", from.Location),
translator.Log);
}
/// <summary>
/// テストデータを用い、Runを通しで実行するテストケース。キャッシュ使用。
/// </summary>
- [Test]
+ [TestMethod]
public void TestExampleWithCache()
{
MockFactory mock = new MockFactory();
Assert.IsNull(table["example.com"].Alias);
Assert.IsNotNull(table["example.com"].Timestamp);
Assert.IsTrue(table.ContainsKey("Exemplum"));
- Assert.IsEmpty(table["Exemplum"].Word);
+ Assert.AreEqual(string.Empty, table["Exemplum"].Word);
Assert.IsNull(table["Exemplum"].Alias);
Assert.IsNotNull(table["Exemplum"].Timestamp);
Assert.IsTrue(table.ContainsKey("example.net"));
// テストデータの変換結果を期待される結果と比較する
// バージョン表記部分は毎回変化するため、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "example_キャッシュ使用.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.xx", "<!-- " + FormUtils.ApplicationName()),
+ File.ReadAllText(Path.Combine(ResultDir, "example_キャッシュ使用.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.xx", "<!-- " + FormUtils.ApplicationName()),
translator.Text);
// テストデータの変換ログを期待されるログと比較する
// 1行目のパスが一致しないので、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "example_キャッシュ使用.log")).Replace("file:///xxx/Data/MediaWiki/en/", from.Location),
+ File.ReadAllText(Path.Combine(ResultDir, "example_キャッシュ使用.log")).Replace("file:///xxx/Data/MediaWiki/en/", from.Location),
translator.Log);
}
/// <summary>
/// テストデータを用い、Runを通しで実行するテストケース。基本動作見出しの変換、{{仮リンク}}への置き換え含む。
/// </summary>
- [Test]
+ [TestMethod]
public void TestExampleWithLinkInterwiki()
{
MockFactory mock = new MockFactory();
// テストデータの変換結果を期待される結果と比較する
// バージョン表記部分は毎回変化するため、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "example_仮リンク有効.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.73", "<!-- " + FormUtils.ApplicationName()),
+ File.ReadAllText(Path.Combine(ResultDir, "example_仮リンク有効.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.73", "<!-- " + FormUtils.ApplicationName()),
translator.Text);
// テストデータの変換ログを期待されるログと比較する
// 1行目のパスが一致しないので、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "example.log")).Replace("http://en.wikipedia.org", from.Location),
+ File.ReadAllText(Path.Combine(ResultDir, "example.log")).Replace("http://en.wikipedia.org", from.Location),
translator.Log);
}
/// テストデータを用い、Runを通しで実行するテストケース（日本語版→英語版）。
/// </summary>
/// <remarks>C++/CLI版の0.73までと同等の動作。</remarks>
- [Test]
+ [TestMethod]
public void TestSpaceShipTwo()
{
MockFactory mock = new MockFactory();
// テストデータの変換結果を期待される結果と比較する
// バージョン表記部分は毎回変化するため、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "スペースシップツー.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.73", "<!-- " + FormUtils.ApplicationName()),
+ File.ReadAllText(Path.Combine(ResultDir, "スペースシップツー.txt")).Replace("<!-- Wikipedia 翻訳支援ツール Ver0.73", "<!-- " + FormUtils.ApplicationName()),
translator.Text);
// テストデータの変換ログを期待されるログと比較する
// 1行目のパスが一致しないので、期待される結果のうち該当部分を更新する
Assert.AreEqual(
- File.ReadAllText(Path.Combine(resultDir, "スペースシップツー.log")).Replace("http://ja.wikipedia.org", from.Location),
+ File.ReadAllText(Path.Combine(ResultDir, "スペースシップツー.log")).Replace("http://ja.wikipedia.org", from.Location),
translator.Log);
}
/// <summary>
/// Runを通しで実行するテストケース（対象記事なし）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestPageNothing()
{
MockFactory mock = new MockFactory();
/// <summary>
/// Runを通しで実行するテストケース（対象記事がリダイレクトで無し）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestPageRedirectNothing()
{
MockFactory mock = new MockFactory();
using System.Collections.Generic;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="Translator"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class TranslatorTest
{
#region プロパティテストケース
/// <summary>
/// <see cref="Translator.ItemTable"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestItemTable()
{
// 初期状態がnull、設定すればそのオブジェクトが返されること
/// <summary>
/// <see cref="Translator.HeadingTable"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestHeadingTable()
{
// 初期状態がnull、設定すればそのオブジェクトが返されること
/// <summary>
/// <see cref="Translator.Log"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestLog()
{
// 初期状態は空
TranslatorMock translator = new TranslatorMock();
- Assert.IsEmpty(translator.Log);
+ Assert.AreEqual(string.Empty, translator.Log);
// 更新時にLogUpdateイベントが実行されること
int count = 0;
/// <summary>
/// <see cref="Translator.Text"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestText()
{
// 初期状態は空
TranslatorMock translator = new TranslatorMock();
- Assert.IsEmpty(translator.Text);
+ Assert.AreEqual(string.Empty, translator.Text);
// null設定時は空白が設定されること、それ以外はそのまま
translator.Text = null;
- Assert.IsEmpty(translator.Text);
+ Assert.AreEqual(string.Empty, translator.Text);
translator.Text = "test";
Assert.AreEqual("test", translator.Text);
}
/// <summary>
/// <see cref="Translator.CancellationPending"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCancellationPending()
{
// 初期状態はfalse、設定すればそのオブジェクトが返されること
/// <summary>
/// <see cref="Translator.From"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestFrom()
{
// 初期状態がnull、設定すればそのオブジェクトが返されること
/// <summary>
/// <see cref="Translator.To"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTo()
{
// 初期状態がnull、設定すればそのオブジェクトが返されること
/// <summary>
/// <see cref="Translator.Create"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCreate()
{
// コンフィグの情報から対応するトランスレータが生成されること
Translator translator = Translator.Create(new MockFactory().GetConfig(), "en", "ja");
Assert.IsNotNull(translator);
- Assert.IsInstanceOf(typeof(MediaWikiTranslator), translator);
+ Assert.IsInstanceOfType(translator, typeof(MediaWikiTranslator));
Assert.IsNotNull(translator.From);
Assert.AreEqual("en", translator.From.Language.Code);
Assert.IsNotNull(translator.To);
/// <summary>
/// <see cref="Translator.Create"/>メソッドテストケース（未対応のトランスレータクラス）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(NotImplementedException))]
public void TestCreateUnsupportedConstructor()
{
/// <summary>
/// <see cref="Translator.Create"/>メソッドテストケース（トランスレータクラス以外の指定）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(InvalidCastException))]
public void TestCreateIgnoreConstructor()
{
/// <summary>
/// <see cref="Translator.Run"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestRun()
{
// ※ Runの処理ではpingも行っているが、そのテストについては2012年2月現在、
// 正常に実行が行えること
// また、実行ごとに結果が初期化されること
translator.Run("test");
- Assert.IsEmpty(translator.Log);
- Assert.IsEmpty(translator.Text);
+ Assert.AreEqual(string.Empty, translator.Log);
+ Assert.AreEqual(string.Empty, translator.Text);
translator.Logger.AddMessage("testlog");
translator.Text = "testtext";
translator.Run("test");
- Assert.IsEmpty(translator.Log);
- Assert.IsEmpty(translator.Text);
+ Assert.AreEqual(string.Empty, translator.Log);
+ Assert.AreEqual(string.Empty, translator.Text);
// 失敗はApplicationExceptionで表現、RunBodyから例外が投げられること
translator.Logger.AddMessage("testlog");
Assert.AreEqual("Dummy", e.Message);
}
- Assert.IsEmpty(translator.Log);
- Assert.IsEmpty(translator.Text);
+ Assert.AreEqual(string.Empty, translator.Log);
+ Assert.AreEqual(string.Empty, translator.Text);
}
/// <summary>
/// <see cref="Translator.Run"/>メソッドテストケース（必須パラメータ未設定）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(InvalidOperationException))]
public void TestRunLangEmpty()
{
using Honememo.Utilities;
using Honememo.Wptscs.Logics;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// Configのテストクラスです。
+ /// <see cref="Config"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class ConfigTest
{
#region 定数
/// <summary>
/// テスト結果が格納されているフォルダパス。
/// </summary>
- private static readonly string resultXml = Path.Combine(MockFactory.TestMediaWikiDir, "result\\config.xml");
+ private static readonly string ResultXml = Path.Combine(MockFactory.TestMediaWikiDir, "result\\config.xml");
#endregion
/// <summary>
/// Fileプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestFile()
{
// 初期状態ではnull、設定すれば設定した値が返る
/// <summary>
/// Translatorプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTranslator()
{
// 初期状態ではnull、設定すれば設定した値が返る
/// <summary>
/// Websitesプロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWebsites()
{
// 初期状態では空のリスト、設定すれば設定した値が返る
/// <summary>
/// Websitesプロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestWebsitesNull()
{
/// <summary>
/// ItemTablesプロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestItemTables()
{
// 初期状態では空のリスト、設定すれば設定した値が返る
/// <summary>
/// ItemTablesプロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestItemTablesNull()
{
/// <summary>
/// HeadingTableプロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestHeadingTable()
{
// 初期状態では空のオブジェクト、設定すれば設定した値が返る
/// <summary>
/// HeadingTableプロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestHeadingTableNull()
{
/// <summary>
/// XMLデシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReadXml()
{
// TODO: デシリアライズでも細かい動作の差異があるので、もう少しテストケースが必要
/// <summary>
/// XMLシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWriteXml()
{
// TODO: シリアライズでも細かい動作の差異があるので、もう少しテストケースが必要
/// <summary>
/// XMLデシリアライズ→シリアライズの通しのテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReadXmlToWriteXml()
{
Config config;
new XmlSerializer(typeof(Config)).Serialize(w, config);
}
- Assert.AreEqual(File.ReadAllText(resultXml), b.ToString());
+ Assert.AreEqual(File.ReadAllText(ResultXml), b.ToString());
}
#endregion
using System.Xml;
using System.Xml.Serialization;
using Honememo.Utilities;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// Languageのテストクラスです。
+ /// <see cref="Language"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class LanguageTest
{
#region プロパティテストケース
/// <summary>
/// Codeプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCode()
{
Language lang = new Language("en");
/// <summary>
/// Codeプロパティテストケース（コードがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestCodeNull()
{
/// <summary>
/// Codeプロパティテストケース（コードが空）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestCodeBlank()
{
/// <summary>
/// Namesプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNames()
{
Language lang = new Language("en");
// 初期状態で空のディクショナリーを作成
- Assert.NotNull(lang.Names);
+ Assert.IsNotNull(lang.Names);
Assert.AreEqual(0, lang.Names.Count);
Language.LanguageName name = new Language.LanguageName { Name = "テスト", ShortName = "テ" };
/// <summary>
/// Namesプロパティテストケース（オブジェクトがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestNamesNull()
{
/// <summary>
/// Bracketプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestBracket()
{
Language lang = new Language("en");
// 消すとデフォルトが有効になること
lang.Bracket = null;
Assert.AreEqual(" ($1) ", lang.Bracket);
- lang.Bracket = String.Empty;
+ lang.Bracket = string.Empty;
Assert.AreEqual(" ($1) ", lang.Bracket);
}
/// <summary>
/// FormatLinkInterwikiメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestFormatLinkInterwiki()
{
Language lang = new Language("en");
/// <summary>
/// XMLデシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReadXml()
{
Language lang;
Assert.AreEqual("Japanese language", lang.Names["en"].Name);
Assert.AreEqual("Japanese", lang.Names["en"].ShortName);
Assert.AreEqual("日语", lang.Names["zh"].Name);
- Assert.IsEmpty(lang.Names["zh"].ShortName);
+ Assert.AreEqual(string.Empty, lang.Names["zh"].ShortName);
Assert.IsFalse(lang.Names.ContainsKey("ja"));
Assert.AreEqual("（{0}）", lang.Bracket);
}
/// <summary>
/// XMLシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWriteXml()
{
Language lang = new Language("ja");
// テスト用にサーバー設定を書き換え
// ※ フルパスじゃないとURIで取得できないので、ここで書き換える必要有り
- UriBuilder b = new UriBuilder("file", String.Empty);
+ UriBuilder b = new UriBuilder("file", string.Empty);
b.Path = Path.GetFullPath(MockFactory.TestMediaWikiDir) + "\\";
wiki.Location = new Uri(b.Uri, lang + "/").ToString();
wiki.ExportPath = "$1.xml";
using System.Text;
using System.Xml;
using System.Xml.Serialization;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// TranslationDictionaryのテストクラスです。
+ /// <see cref="TranslationDictionary"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class TranslationDictionaryTest
{
#region XMLシリアライズ用メソッドテストケース
/// <summary>
/// XMLデシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReadXml()
{
// TODO: リダイレクトとタイムスタンプも
/// <summary>
/// XMLシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWriteXml()
{
// TODO: リダイレクトとタイムスタンプも
using System.Text;
using System.Xml;
using System.Xml.Serialization;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// TranslationTableのテストクラスです。
+ /// <see cref="TranslationTable"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class TranslationTableTest
{
#region 公開メソッドテストケース
/// <summary>
/// GetWordメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetWord()
{
TranslationTable table = new TranslationTable();
Assert.AreEqual("関連項目", table.GetWord("see also"));
Assert.AreEqual("関連項目", table.GetWord("see"));
Assert.IsNull(table.GetWord("test"));
- Assert.IsNull(table.GetWord(String.Empty));
+ Assert.IsNull(table.GetWord(string.Empty));
Assert.AreEqual("See also", table.GetWord("ja", "en", "関連項目"));
- Assert.IsNull(table.GetWord("ja", "en", String.Empty));
- Assert.IsNull(table.GetWord("ja", String.Empty, String.Empty));
- Assert.IsNull(table.GetWord(String.Empty, String.Empty, String.Empty));
+ Assert.IsNull(table.GetWord("ja", "en", string.Empty));
+ Assert.IsNull(table.GetWord("ja", string.Empty, string.Empty));
+ Assert.IsNull(table.GetWord(string.Empty, string.Empty, string.Empty));
}
/// <summary>
/// GetWordメソッドテストケース（fromがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestGetWordFromNull()
{
/// <summary>
/// GetWordメソッドテストケース（toがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestGetWordToNull()
{
/// <summary>
/// GetWordメソッドテストケース（wordがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestGetWordWordNull()
{
/// <summary>
/// GetWordメソッドテストケース（プロパティがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(InvalidOperationException))]
public void TestGetWordPropertyNull()
{
/// <summary>
/// XMLデシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReadXml()
{
TranslationTable table;
/// <summary>
/// XMLシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWriteXml()
{
TranslationTable table = new TranslationTable();
using Honememo.Parsers;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiHeadingParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiHeadingParserTest
{
#region private変数
/// <summary>
/// 前処理・後処理で生成／解放される言語別の<see cref="MediaWikiParser"/>。
/// </summary>
- private IDictionary<string, MediaWikiParser> mediaWikiParsers = new Dictionary<string, MediaWikiParser>();
+ private static IDictionary<string, MediaWikiParser> mediaWikiParsers = new Dictionary<string, MediaWikiParser>();
#endregion
/// <summary>
/// テストの前処理。
/// </summary>
+ /// <param name="context">テスト用情報。</param>
/// <remarks><see cref="MediaWikiParser.Dispose"/>が必要な<see cref="MediaWikiParser"/>の生成。</remarks>
- [TestFixtureSetUp]
- public void SetUpBeforeClass()
+ [ClassInitialize]
+ public static void SetUpBeforeClass(TestContext context)
{
- this.mediaWikiParsers["en"] = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
+ mediaWikiParsers["en"] = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
}
/// <summary>
/// テストの後処理。
/// </summary>
/// <remarks><see cref="MediaWikiParser.Dispose"/>が必要な<see cref="MediaWikiParser"/>の解放。</remarks>
- [TestFixtureTearDown]
- public void TearDownAfterClass()
+ [ClassCleanup]
+ public static void TearDownAfterClass()
{
- foreach (IDisposable parser in this.mediaWikiParsers.Values)
+ foreach (IDisposable parser in mediaWikiParsers.Values)
{
parser.Dispose();
}
- this.mediaWikiParsers.Clear();
+ mediaWikiParsers.Clear();
}
#endregion
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
// TODO: ちゃんと設定されているかも確認する？
/// <summary>
/// <see cref="MediaWikiHeadingParser.TryParse"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParse()
{
IElement element;
MediaWikiHeading heading;
- MediaWikiHeadingParser parser = new MediaWikiHeadingParser(this.mediaWikiParsers["en"]);
+ MediaWikiHeadingParser parser = new MediaWikiHeadingParser(mediaWikiParsers["en"]);
// 基本形
Assert.IsTrue(parser.TryParse("==test==", out element));
- Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
heading = (MediaWikiHeading)element;
Assert.AreEqual("==test==", heading.ToString());
Assert.AreEqual(2, heading.Level);
// 後ろが改行
Assert.IsTrue(parser.TryParse("== test == \r\ntest", out element));
- Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
heading = (MediaWikiHeading)element;
Assert.AreEqual("== test == ", heading.ToString());
Assert.AreEqual(2, heading.Level);
Assert.IsNull(element);
// 複数の要素を含む
- Assert.IsTrue(parser.TryParse("===[[test]] and sample===", out element));
- Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ Assert.IsTrue(parser.TryParse("===[[TestMethod]] and sample===", out element));
+ Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
heading = (MediaWikiHeading)element;
- Assert.AreEqual("===[[test]] and sample===", heading.ToString());
+ Assert.AreEqual("===[[TestMethod]] and sample===", heading.ToString());
Assert.AreEqual(3, heading.Level);
Assert.AreEqual(2, heading.Count);
- Assert.AreEqual("[[test]]", heading[0].ToString());
- Assert.IsInstanceOf(typeof(MediaWikiLink), heading[0]);
+ Assert.AreEqual("[[TestMethod]]", heading[0].ToString());
+ Assert.IsInstanceOfType(heading[0], typeof(MediaWikiLink));
Assert.AreEqual(" and sample", heading[1].ToString());
// 前後で数が違うのはOK、少ない側の階層と判定
Assert.IsTrue(parser.TryParse("=test==", out element));
- Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
heading = (MediaWikiHeading)element;
Assert.AreEqual("=test==", heading.ToString());
Assert.AreEqual(1, heading.Level);
// 前後で数が違うの逆パターン
Assert.IsTrue(parser.TryParse("====test==", out element));
- Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
heading = (MediaWikiHeading)element;
Assert.AreEqual("====test==", heading.ToString());
Assert.AreEqual(2, heading.Level);
// 内部要素に改行を含むのはOK
Assert.IsTrue(parser.TryParse("== {{lang\n|ja|見出し}} ==\n", out element));
- Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
heading = (MediaWikiHeading)element;
Assert.AreEqual("== {{lang\n|ja|見出し}} ==", heading.ToString());
Assert.AreEqual(2, heading.Level);
Assert.AreEqual(3, heading.Count);
Assert.AreEqual(" ", heading[0].ToString());
Assert.AreEqual("{{lang\n|ja|見出し}}", heading[1].ToString());
- Assert.IsInstanceOf(typeof(MediaWikiTemplate), heading[1]);
+ Assert.IsInstanceOfType(heading[1], typeof(MediaWikiTemplate));
Assert.AreEqual(" ", heading[2].ToString());
// 空・null
- Assert.IsFalse(parser.TryParse(String.Empty, out element));
+ Assert.IsFalse(parser.TryParse(string.Empty, out element));
Assert.IsNull(element);
Assert.IsFalse(parser.TryParse(null, out element));
Assert.IsNull(element);
/// <summary>
/// <see cref="MediaWikiHeadingParser.TryParse"/>メソッドテストケース（コメント）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseComment()
{
IElement element;
MediaWikiHeading heading;
- MediaWikiHeadingParser parser = new MediaWikiHeadingParser(this.mediaWikiParsers["en"]);
+ MediaWikiHeadingParser parser = new MediaWikiHeadingParser(mediaWikiParsers["en"]);
// ↓1.01以前のバージョンで対応していたコメント、中のコメントが認識されなかった
// // こんな無茶なコメントも一応対応
// Assert.IsTrue(parser.TryParse("<!--test-->=<!--test-->=関連項目<!--test-->==<!--test-->\n", out element));
- // Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ // Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
// heading = (MediaWikiHeading)element;
// Assert.AreEqual("<!--test-->=<!--test-->=関連項目<!--test-->==<!--test-->", heading.ToString());
// Assert.AreEqual(2, heading.Level);
// ↓1.10改修後での動作
Assert.IsFalse(parser.TryParse("<!--test-->=<!--test-->=関連項目<!--test-->==<!--test-->\n", out element));
Assert.IsTrue(parser.TryParse("=<!--test-->=関連項目<!--test-->==\n", out element));
- Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
heading = (MediaWikiHeading)element;
Assert.AreEqual(1, heading.Level);
Assert.AreEqual(4, heading.Count);
// ↓1.10改修後に対応しているコメント、変なところのコメントは駄目だが中のものを認識する
Assert.IsTrue(parser.TryParse("==<!--test1-->関連項目<!--test2-->==\n", out element));
- Assert.IsInstanceOf(typeof(MediaWikiHeading), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiHeading));
heading = (MediaWikiHeading)element;
Assert.AreEqual("==<!--test1-->関連項目<!--test2-->==", heading.ToString());
Assert.AreEqual(2, heading.Level);
Assert.AreEqual(3, heading.Count);
Assert.AreEqual("<!--test1-->", heading[0].ToString());
- Assert.IsInstanceOf(typeof(XmlCommentElement), heading[0]);
+ Assert.IsInstanceOfType(heading[0], typeof(XmlCommentElement));
Assert.AreEqual("関連項目", heading[1].ToString());
Assert.AreEqual("<!--test2-->", heading[2].ToString());
}
{
using System;
using Honememo.Parsers;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// MediaWikiHeadingのテストクラスです。
+ /// <see cref="MediaWikiHeading"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class MediaWikiHeadingTest
{
#region プロパティテストケース
/// <summary>
/// Levelプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestLevel()
{
MediaWikiHeading element = new MediaWikiHeading();
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
MediaWikiHeading element = new MediaWikiHeading();
// 初期状態
- Assert.IsEmpty(element.ToString());
+ Assert.AreEqual(string.Empty, element.ToString());
// 見出し1階層
element.Level = 1;
using Honememo.Parsers;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiLinkParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiLinkParserTest
{
#region private変数
/// <summary>
/// 前処理・後処理で生成／解放される言語別の<see cref="MediaWikiParser"/>。
/// </summary>
- private IDictionary<string, MediaWikiParser> mediaWikiParsers = new Dictionary<string, MediaWikiParser>();
+ private static IDictionary<string, MediaWikiParser> mediaWikiParsers = new Dictionary<string, MediaWikiParser>();
#endregion
/// <summary>
/// テストの前処理。
/// </summary>
+ /// <param name="context">テスト用情報。</param>
/// <remarks><see cref="MediaWikiParser.Dispose"/>が必要な<see cref="MediaWikiParser"/>の生成。</remarks>
- [TestFixtureSetUp]
- public void SetUpBeforeClass()
+ [ClassInitialize]
+ public static void SetUpBeforeClass(TestContext context)
{
- this.mediaWikiParsers["en"] = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
- this.mediaWikiParsers["ja"] = new MediaWikiParser(new MockFactory().GetMediaWiki("ja"));
+ mediaWikiParsers["en"] = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
+ mediaWikiParsers["ja"] = new MediaWikiParser(new MockFactory().GetMediaWiki("ja"));
}
/// <summary>
/// テストの後処理。
/// </summary>
/// <remarks><see cref="MediaWikiParser.Dispose"/>が必要な<see cref="MediaWikiParser"/>の解放。</remarks>
- [TestFixtureTearDown]
- public void TearDownAfterClass()
+ [ClassCleanup]
+ public static void TearDownAfterClass()
{
- foreach (IDisposable parser in this.mediaWikiParsers.Values)
+ foreach (IDisposable parser in mediaWikiParsers.Values)
{
parser.Dispose();
}
- this.mediaWikiParsers.Clear();
+ mediaWikiParsers.Clear();
}
#endregion
/// <summary>
/// <see cref="MediaWikiLinkParser.TryParse"/>メソッドテストケース（基本的な構文）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseBasic()
{
IElement element;
MediaWikiLink link;
- MediaWikiLinkParser parser = new MediaWikiLinkParser(this.mediaWikiParsers["en"]);
+ MediaWikiLinkParser parser = new MediaWikiLinkParser(mediaWikiParsers["en"]);
// タイトルのみ
Assert.IsTrue(parser.TryParse("[[testtitle]]", out element));
/// <summary>
/// <see cref="MediaWikiLinkParser.TryParse"/>メソッドテストケース（NGパターン）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNg()
{
IElement element;
- MediaWikiLinkParser parser = new MediaWikiLinkParser(this.mediaWikiParsers["en"]);
+ MediaWikiLinkParser parser = new MediaWikiLinkParser(mediaWikiParsers["en"]);
// 開始タグが無い
Assert.IsFalse(parser.TryParse("testtitle]]", out element));
Assert.IsFalse(parser.TryParse("[[test<title]]", out element));
Assert.IsFalse(parser.TryParse("[[test>title]]", out element));
Assert.IsFalse(parser.TryParse("[[test[title]]", out element));
- Assert.IsFalse(parser.TryParse("[[test]title]]", out element));
+ Assert.IsFalse(parser.TryParse("[[TestMethod]title]]", out element));
Assert.IsFalse(parser.TryParse("[[test{title]]", out element));
Assert.IsFalse(parser.TryParse("[[test}title]]", out element));
Assert.IsFalse(parser.TryParse("[[testtitle\n]]", out element));
// 空・null
- Assert.IsFalse(parser.TryParse(String.Empty, out element));
+ Assert.IsFalse(parser.TryParse(string.Empty, out element));
Assert.IsFalse(parser.TryParse(null, out element));
}
/// <summary>
/// <see cref="MediaWikiLinkParser.TryParse"/>メソッドテストケース（入れ子）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNested()
{
IElement element;
MediaWikiLink link;
- MediaWikiLinkParser parser = new MediaWikiLinkParser(this.mediaWikiParsers["en"]);
+ MediaWikiLinkParser parser = new MediaWikiLinkParser(mediaWikiParsers["en"]);
// テンプレートはパイプ以後にある分には全てOK
Assert.IsTrue(parser.TryParse("[[ロシア語|{{lang|ru|русский язык}}]]", out element));
/// <summary>
/// <see cref="MediaWikiLinkParser.TryParse"/>メソッドテストケース（名前空間）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNamespace()
{
IElement element;
MediaWikiLink link;
- MediaWikiLinkParser parser = new MediaWikiLinkParser(this.mediaWikiParsers["ja"]);
+ MediaWikiLinkParser parser = new MediaWikiLinkParser(mediaWikiParsers["ja"]);
// カテゴリ標準
Assert.IsTrue(parser.TryParse("[[Category:test]]", out element));
Assert.AreEqual("thumb", link.PipeTexts[0].ToString());
Assert.AreEqual("100px", link.PipeTexts[1].ToString());
Assert.AreEqual("テスト[[画像]]", link.PipeTexts[2].ToString());
- Assert.IsInstanceOf(typeof(ListElement), link.PipeTexts[2]);
+ Assert.IsInstanceOfType(link.PipeTexts[2], typeof(ListElement));
ListElement list = (ListElement)link.PipeTexts[2];
Assert.AreEqual(2, list.Count);
Assert.AreEqual("テスト", list[0].ToString());
/// <summary>
/// <see cref="MediaWikiLinkParser.TryParse"/>メソッドテストケース（サブページ）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseSubpage()
{
IElement element;
MediaWikiLink link;
- MediaWikiLinkParser parser = new MediaWikiLinkParser(this.mediaWikiParsers["en"]);
+ MediaWikiLinkParser parser = new MediaWikiLinkParser(mediaWikiParsers["en"]);
// 全て指定されているケースは通常の記事と同じ扱い
Assert.IsTrue(parser.TryParse("[[testtitle/subpage]]", out element));
/// <summary>
/// <see cref="MediaWikiLinkParser.TryParse"/>メソッドテストケース（ウィキ間リンク）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseInterwiki()
{
IElement element;
MediaWikiLink link;
- MediaWikiLinkParser parser = new MediaWikiLinkParser(this.mediaWikiParsers["en"]);
+ MediaWikiLinkParser parser = new MediaWikiLinkParser(mediaWikiParsers["en"]);
// タイトルとセクションとパイプ後の文字列とウィキ間リンクとコロンの全部入り
Assert.IsTrue(parser.TryParse("[[:en:testtitle#testsection|testpipe1|testpipe2]]", out element));
using System;
using System.Collections.Generic;
using Honememo.Parsers;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// MediaWikiLinkのテストクラスです。
+ /// <see cref="MediaWikiLink"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class MediaWikiLinkTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
MediaWikiLink element;
/// <summary>
/// Titleプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTitle()
{
MediaWikiLink element = new MediaWikiLink();
/// <summary>
/// Sectionプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestSection()
{
MediaWikiLink element = new MediaWikiLink();
/// <summary>
/// PipeTextsプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestPipeTexts()
{
MediaWikiLink element = new MediaWikiLink();
/// <summary>
/// Interwikiプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestInterwiki()
{
MediaWikiLink element = new MediaWikiLink();
/// <summary>
/// IsColonプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsColon()
{
MediaWikiLink element = new MediaWikiLink();
/// <summary>
/// IsSubpageメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsSubpage()
{
MediaWikiLink element = new MediaWikiLink();
/// <summary>
/// GetLinkStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetLinkString()
{
MediaWikiLink element = new MediaWikiLink();
Assert.AreEqual("testtitle", element.GetLinkString());
// タイトルとセクション
- element.Section = String.Empty;
+ element.Section = string.Empty;
Assert.AreEqual("testtitle#", element.GetLinkString());
element.Section = "testsection";
Assert.AreEqual("testtitle#testsection", element.GetLinkString());
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
MediaWikiLink element = new MediaWikiLink();
Assert.AreEqual("[[testtitle]]", element.ToString());
// タイトルとセクション
- element.Section = String.Empty;
+ element.Section = string.Empty;
Assert.AreEqual("[[testtitle#]]", element.ToString());
element.Section = "testsection";
Assert.AreEqual("[[testtitle#testsection]]", element.ToString());
using System.Collections.Generic;
using Honememo.Parsers;
using Honememo.Wptscs.Models;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiNowikiParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiNowikiParserTest
{
#region private変数
/// テストの前処理。
/// </summary>
/// <remarks><see cref="XmlParser.Dispose"/>が必要な<see cref="XmlParser"/>の生成。</remarks>
- [TestFixtureSetUp]
- public void SetUpBeforeClass()
+ [TestInitialize]
+ public void SetUp()
{
this.xmlParser = new XmlParser();
}
/// テストの後処理。
/// </summary>
/// <remarks><see cref="XmlParser.Dispose"/>が必要な<see cref="XmlParser"/>の解放。</remarks>
- [TestFixtureTearDown]
- public void TearDownAfterClass()
+ [TestCleanup]
+ public void TearDown()
{
this.xmlParser.Dispose();
}
/// <summary>
/// <see cref="MediaWikiNowikiParser.TryParse"/>メソッドテストケース（OKケース）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParse()
{
IElement element;
MediaWikiNowikiParser parser = new MediaWikiNowikiParser(this.xmlParser);
// 基本動作、nowiki区間は再帰的に処理されない
- Assert.IsTrue(parser.TryParse("<nowiki>[[test]]</nowiki>", out element));
- Assert.AreEqual("<nowiki>[[test]]</nowiki>", element.ToString());
- Assert.IsInstanceOf(typeof(XmlElement), element);
+ Assert.IsTrue(parser.TryParse("<nowiki>[[TestMethod]]</nowiki>", out element));
+ Assert.AreEqual("<nowiki>[[TestMethod]]</nowiki>", element.ToString());
+ Assert.IsInstanceOfType(element, typeof(XmlElement));
xml = (XmlElement)element;
- Assert.IsInstanceOf(typeof(XmlTextElement), xml[0]);
- Assert.AreEqual("[[test]]", xml[0].ToString());
+ Assert.IsInstanceOfType(xml[0], typeof(XmlTextElement));
+ Assert.AreEqual("[[TestMethod]]", xml[0].ToString());
Assert.AreEqual(1, xml.Count);
Assert.IsTrue(parser.TryParse("<noWiki>{{!}}<nowiki>nowikiサンプルのつもり</nowiki>{{!}}</nowiki>", out element));
Assert.AreEqual("<noWiki>{{!}}<nowiki>nowikiサンプルのつもり</nowiki>", element.ToString());
- Assert.IsInstanceOf(typeof(XmlElement), element);
+ Assert.IsInstanceOfType(element, typeof(XmlElement));
xml = (XmlElement)element;
- Assert.IsInstanceOf(typeof(XmlTextElement), xml[0]);
+ Assert.IsInstanceOfType(xml[0], typeof(XmlTextElement));
Assert.AreEqual("{{!}}<nowiki>nowikiサンプルのつもり", xml[0].ToString());
Assert.AreEqual(1, xml.Count);
Assert.IsTrue(parser.TryParse("<nowiki>{{!}}<nowiki>nowikiサンプル</nowiki>{{!}}</nowiki>", out element));
Assert.AreEqual("<nowiki>{{!}}<nowiki>nowikiサンプル</nowiki>{{!}}</nowiki>", element.ToString());
- Assert.IsInstanceOf(typeof(XmlElement), element);
+ Assert.IsInstanceOfType(element, typeof(XmlElement));
xml = (XmlElement)element;
- Assert.IsInstanceOf(typeof(XmlTextElement), xml[0]);
+ Assert.IsInstanceOfType(xml[0], typeof(XmlTextElement));
Assert.AreEqual("{{!}}<nowiki>nowikiサンプル</nowiki>{{!}}", xml[0].ToString());
Assert.AreEqual(1, xml.Count);
// （その判断はMediaWikiNowikiParserではなくMediaWikiParserでの設定次第によるものだが）
// 属性値などが指定されていても機能する
// nowiki区間ではコメントも機能しない
- Assert.IsTrue(parser.TryParse("<NOWIKI>[[test]]</NOWIKI>", out element));
- Assert.AreEqual("<NOWIKI>[[test]]</NOWIKI>", element.ToString());
+ Assert.IsTrue(parser.TryParse("<NOWIKI>[[TestMethod]]</NOWIKI>", out element));
+ Assert.AreEqual("<NOWIKI>[[TestMethod]]</NOWIKI>", element.ToString());
- Assert.IsTrue(parser.TryParse("<Nowiki>[[test]]</noWiki>", out element));
- Assert.AreEqual("<Nowiki>[[test]]</noWiki>", element.ToString());
+ Assert.IsTrue(parser.TryParse("<Nowiki>[[TestMethod]]</noWiki>", out element));
+ Assert.AreEqual("<Nowiki>[[TestMethod]]</noWiki>", element.ToString());
- Assert.IsTrue(parser.TryParse("<nowiki>[[test]]</nowiki></nowiki>", out element));
- Assert.AreEqual("<nowiki>[[test]]</nowiki>", element.ToString());
+ Assert.IsTrue(parser.TryParse("<nowiki>[[TestMethod]]</nowiki></nowiki>", out element));
+ Assert.AreEqual("<nowiki>[[TestMethod]]</nowiki>", element.ToString());
- Assert.IsTrue(parser.TryParse("<nowiki>[[test]]nowiki", out element));
- Assert.AreEqual("<nowiki>[[test]]nowiki", element.ToString());
+ Assert.IsTrue(parser.TryParse("<nowiki>[[TestMethod]]nowiki", out element));
+ Assert.AreEqual("<nowiki>[[TestMethod]]nowiki", element.ToString());
- Assert.IsTrue(parser.TryParse("<nowiki>\n\n[[test]]\r\n</nowiki>", out element));
- Assert.AreEqual("<nowiki>\n\n[[test]]\r\n</nowiki>", element.ToString());
+ Assert.IsTrue(parser.TryParse("<nowiki>\n\n[[TestMethod]]\r\n</nowiki>", out element));
+ Assert.AreEqual("<nowiki>\n\n[[TestMethod]]\r\n</nowiki>", element.ToString());
- Assert.IsTrue(parser.TryParse("<nowiki><!--[[test]]--></nowiki>", out element));
- Assert.AreEqual("<nowiki><!--[[test]]--></nowiki>", element.ToString());
+ Assert.IsTrue(parser.TryParse("<nowiki><!--[[TestMethod]]--></nowiki>", out element));
+ Assert.AreEqual("<nowiki><!--[[TestMethod]]--></nowiki>", element.ToString());
- Assert.IsTrue(parser.TryParse("<nowiki><!--<nowiki>[[test]]</nowiki>--></nowiki>", out element));
- Assert.AreEqual("<nowiki><!--<nowiki>[[test]]</nowiki>", element.ToString());
+ Assert.IsTrue(parser.TryParse("<nowiki><!--<nowiki>[[TestMethod]]</nowiki>--></nowiki>", out element));
+ Assert.AreEqual("<nowiki><!--<nowiki>[[TestMethod]]</nowiki>", element.ToString());
- Assert.IsTrue(parser.TryParse("<nowiki><!--[[test]]", out element));
- Assert.AreEqual("<nowiki><!--[[test]]", element.ToString());
+ Assert.IsTrue(parser.TryParse("<nowiki><!--[[TestMethod]]", out element));
+ Assert.AreEqual("<nowiki><!--[[TestMethod]]", element.ToString());
- Assert.IsTrue(parser.TryParse("<nowiki attr=\"Value\">[[test]]</nowiki>", out element));
- Assert.AreEqual("<nowiki attr=\"Value\">[[test]]</nowiki>", element.ToString());
+ Assert.IsTrue(parser.TryParse("<nowiki attr=\"Value\">[[TestMethod]]</nowiki>", out element));
+ Assert.AreEqual("<nowiki attr=\"Value\">[[TestMethod]]</nowiki>", element.ToString());
}
/// <summary>
/// <see cref="MediaWikiNowikiParser.TryParse"/>メソッドテストケース（NGケース）。
/// </summary>
/// <remarks>nowiki以外のタグの場合に変な動きをしているようなバグがあったためその確認も行う。</remarks>
- [Test]
+ [TestMethod]
public void TestTryParseNg()
{
IElement element;
MediaWikiNowikiParser parser = new MediaWikiNowikiParser(this.xmlParser);
- Assert.IsFalse(parser.TryParse("<nowik>[[test]]</nowik>", out element));
+ Assert.IsFalse(parser.TryParse("<nowik>[[TestMethod]]</nowik>", out element));
Assert.IsNull(element);
- Assert.IsFalse(parser.TryParse("<nowiki[[test]]</nowiki>", out element));
+ Assert.IsFalse(parser.TryParse("<nowiki[[TestMethod]]</nowiki>", out element));
Assert.IsNull(element);
- Assert.IsFalse(parser.TryParse(String.Empty, out element));
+ Assert.IsFalse(parser.TryParse(string.Empty, out element));
Assert.IsNull(element);
Assert.IsFalse(parser.TryParse(null, out element));
using Honememo.Parsers;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiParserTest
{
#region 公開プロパティテストケース
/// <summary>
/// <see cref="MediaWikiParser.Website"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWebsite()
{
MediaWiki site = new MediaWiki(new Language("en"));
/// <summary>
/// <see cref="MediaWikiParser.Website"/>プロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestWebsiteNull()
{
/// <see cref="MediaWikiParser.TryParseToEndCondition"/>
/// メソッドテストケース（実際のデータを想定）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseToEndCondition()
{
- string text = "'''Article Name''' is [[xxx]]\r\n==test head==\r\n<p>test</p><nowiki>[[test]]</nowiki><!--comment-->{{reflist}}";
+ string text = "'''Article Name''' is [[xxx]]\r\n==test head==\r\n<p>test</p><nowiki>[[TestMethod]]</nowiki><!--comment-->{{reflist}}";
IElement element;
using (MediaWikiParser parser = new MediaWikiParser(new MockFactory().GetMediaWiki("en")))
{
}
Assert.AreEqual(text, element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
ListElement list = (ListElement)element;
Assert.AreEqual(8, list.Count);
Assert.AreEqual("'''Article Name''' is ", list[0].ToString());
Assert.AreEqual("\r\n", list[2].ToString());
Assert.AreEqual("==test head==", list[3].ToString());
Assert.AreEqual("\r\n<p>test</p>", list[4].ToString());
- Assert.AreEqual("<nowiki>[[test]]</nowiki>", list[5].ToString());
+ Assert.AreEqual("<nowiki>[[TestMethod]]</nowiki>", list[5].ToString());
Assert.AreEqual("<!--comment-->", list[6].ToString());
Assert.AreEqual("{{reflist}}", list[7].ToString());
}
/// <see cref="MediaWikiParser.TryParseToEndCondition"/>
/// メソッドテストケース（その他のケース）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseToEndConditionEmpty()
{
IElement element;
using (MediaWikiParser parser = new MediaWikiParser(new MockFactory().GetMediaWiki("en")))
{
// 空文字列、一応解析成功となる
- Assert.IsTrue(parser.TryParseToEndCondition(String.Empty, null, out element));
- Assert.AreEqual(String.Empty, element.ToString());
- Assert.IsInstanceOf(typeof(TextElement), element);
+ Assert.IsTrue(parser.TryParseToEndCondition(string.Empty, null, out element));
+ Assert.AreEqual(string.Empty, element.ToString());
+ Assert.IsInstanceOfType(element, typeof(TextElement));
// nullは解析失敗
Assert.IsFalse(parser.TryParseToEndCondition(null, null, out element));
/// <see cref="MediaWikiParser.TryParseToEndCondition"/>
/// メソッドテストケース（終了条件）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseToEndConditionCondition()
{
// 親クラスにあった終了条件で停止する動作が継承先でも動作していること
- string text = "'''Article Name''' is [[xxx]]\r\n==test head==\r\n<p>test</p><nowiki>[[test]]</nowiki><!--comment-->{{reflist}}";
+ string text = "'''Article Name''' is [[xxx]]\r\n==test head==\r\n<p>test</p><nowiki>[[TestMethod]]</nowiki><!--comment-->{{reflist}}";
IElement element;
using (MediaWikiParser parser = new MediaWikiParser(new MockFactory().GetMediaWiki("en")))
{
}
Assert.AreEqual("'''Article Name''' is [[xxx]]\r\n==test head==\r\n<p>test<", element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
ListElement list = (ListElement)element;
Assert.AreEqual(5, list.Count);
}
/// Ver 1.11にて解析失敗時のリトライにより極端に時間がかかっていたデータ。
/// 中身についてはほぼ処理できない類のものだが、現実的な時間で解析が終わることだけ検証。
/// </remarks>
- [Test, Timeout(20000)]
+ [TestMethod, Timeout(20000)]
public void TestTryParseToEndConditionTemplateContext()
{
IElement element;
{
string text = parser.Website.GetPage("Template:context").Text;
Assert.IsTrue(parser.TryParseToEndCondition(text, null, out element));
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
Assert.AreEqual(text, element.ToString());
}
}
/// <see cref="MediaWikiParser.TryParseToEndCondition"/>
/// メソッドテストケース（Dispose）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public void TestTryParseToEndConditionDispose()
{
MediaWikiParser parser = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
parser.Dispose();
IElement result;
- parser.TryParseToEndCondition(String.Empty, null, out result);
+ parser.TryParseToEndCondition(string.Empty, null, out result);
}
#endregion
using Honememo.Parsers;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiPreparser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiPreparserTest
{
#region 定数
/// <summary>
/// <see cref="IParser.Parse"/>メソッドテストトケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestParse()
{
IElement element;
Assert.AreEqual(TestDataWithoutOnlyinclude, element.ToString());
// includeonly, noinclude, nowiki, コメントのみ特別な要素として認識する
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
ListElement list = (ListElement)element;
Assert.AreEqual("This template is [[xxx]]<br />\r\n", list[0].ToString());
Assert.AreEqual("<noWiki><nowiki>sample</nowiki>", list[1].ToString());
Assert.AreEqual(8, list.Count);
// 各要素の確認
- Assert.IsInstanceOf(typeof(TextElement), list[0]);
+ Assert.IsInstanceOfType(list[0], typeof(TextElement));
// nowikiとコメントは再帰的に解析されない
- Assert.IsInstanceOf(typeof(XmlElement), list[1]);
+ Assert.IsInstanceOfType(list[1], typeof(XmlElement));
xml = (XmlElement)list[1];
Assert.AreEqual("<nowiki>sample", xml[0].ToString());
- Assert.IsInstanceOf(typeof(XmlTextElement), xml[0]);
- Assert.IsInstanceOf(typeof(XmlCommentElement), list[7]);
+ Assert.IsInstanceOfType(xml[0], typeof(XmlTextElement));
+ Assert.IsInstanceOfType(list[7], typeof(XmlCommentElement));
// includeonly, noincludeは再帰的に処理
- Assert.IsInstanceOf(typeof(XmlElement), list[3]);
+ Assert.IsInstanceOfType(list[3], typeof(XmlElement));
xml = (XmlElement)list[3];
Assert.AreEqual("<p>include text", xml[0].ToString());
Assert.AreEqual("<nowiki><includeonly>sample</includeonly></nowiki>", xml[1].ToString());
- Assert.IsInstanceOf(typeof(XmlElement), xml[1]);
+ Assert.IsInstanceOfType(xml[1], typeof(XmlElement));
Assert.AreEqual("</p>", xml[2].ToString());
Assert.AreEqual(3, xml.Count);
- Assert.IsInstanceOf(typeof(XmlElement), list[5]);
+ Assert.IsInstanceOfType(list[5], typeof(XmlElement));
xml = (XmlElement)list[5];
Assert.AreEqual("[[ja:Template:sample/doc]]", xml[0].ToString());
- Assert.IsInstanceOf(typeof(TextElement), xml[0]);
+ Assert.IsInstanceOfType(xml[0], typeof(TextElement));
Assert.AreEqual("<!--noinclude only-->", xml[1].ToString());
- Assert.IsInstanceOf(typeof(XmlCommentElement), xml[1]);
+ Assert.IsInstanceOfType(xml[1], typeof(XmlCommentElement));
Assert.AreEqual(2, xml.Count);
}
/// <summary>
/// <see cref="IParser.Parse"/>メソッドテストトケース（onlyinclude）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestParseOnlyinclude()
{
IElement element;
// onlyincludeが存在するケース、解析時点では特に他のタグと同じ扱い
// ※ 前半部分はTestParseと同じデータなので割愛
Assert.AreEqual(TestData, element.ToString());
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
ListElement list = (ListElement)element;
Assert.AreEqual("<onlyinclude><noinclude>インクルード時は</noinclude>ここしか</onlyinclude>", list[8].ToString());
Assert.AreEqual(", ", list[9].ToString());
Assert.AreEqual(11, list.Count);
// onlyincludeも再帰的に処理
- Assert.IsInstanceOf(typeof(XmlElement), list[8]);
+ Assert.IsInstanceOfType(list[8], typeof(XmlElement));
xml = (XmlElement)list[8];
Assert.AreEqual("<noinclude>インクルード時は</noinclude>", xml[0].ToString());
- Assert.IsInstanceOf(typeof(XmlElement), xml[0]);
+ Assert.IsInstanceOfType(xml[0], typeof(XmlElement));
Assert.AreEqual("ここしか", xml[1].ToString());
Assert.AreEqual(2, xml.Count);
}
/// <remarks>
/// <see cref="TestParse"/>と同じデータを使うため、そちらのテストが通っていることを前提とする。
/// </remarks>
- [Test]
+ [TestMethod]
public void TestFilterByInclude()
{
IElement element;
}
// includeonlyが展開され、noinclude, コメントが削除される
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
list = (ListElement)element;
Assert.AreEqual("This template is [[xxx]]<br />\r\n", list[0].ToString());
Assert.AreEqual("<noWiki><nowiki>sample</nowiki>", list[1].ToString());
Assert.AreEqual(6, list.Count);
// 各要素の確認
- Assert.IsInstanceOf(typeof(TextElement), list[0]);
- Assert.IsInstanceOf(typeof(XmlElement), list[1]);
+ Assert.IsInstanceOfType(list[0], typeof(TextElement));
+ Assert.IsInstanceOfType(list[1], typeof(XmlElement));
// includeonlyはListElementに置き換わる
- Assert.IsInstanceOf(typeof(ListElement), list[3]);
+ Assert.IsInstanceOfType(list[3], typeof(ListElement));
list = (ListElement)list[3];
Assert.AreEqual("<p>include text", list[0].ToString());
Assert.AreEqual("<nowiki><includeonly>sample</includeonly></nowiki>", list[1].ToString());
- Assert.IsInstanceOf(typeof(XmlElement), list[1]);
+ Assert.IsInstanceOfType(list[1], typeof(XmlElement));
Assert.AreEqual("</p>", list[2].ToString());
Assert.AreEqual(3, list.Count);
}
/// <remarks>
/// <see cref="TestParseOnlyinclude"/>と同じデータを使うため、そちらのテストが通っていることを前提とする。
/// </remarks>
- [Test]
+ [TestMethod]
public void TestFilterByIncludeOnlyinclude()
{
IElement element;
// onlyincludeが存在する場合、その外側は全て削除され、タグが展開される
// ※ onlyincludeの内部にnoinclude等が存在する場合、それはそれで通常と同様処理される
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
list = (ListElement)element;
Assert.AreEqual("ここしか", list[0].ToString());
Assert.AreEqual("有効にならない", list[1].ToString());
Assert.AreEqual(2, list.Count);
// onlyincludeはListElementに置き換わる
- Assert.IsInstanceOf(typeof(ListElement), list[0]);
- Assert.IsInstanceOf(typeof(ListElement), list[1]);
+ Assert.IsInstanceOfType(list[0], typeof(ListElement));
+ Assert.IsInstanceOfType(list[1], typeof(ListElement));
}
/// <summary>
/// <see cref="MediaWikiPreparser.FilterByInclude"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestFilterByIncludeNull()
{
/// <remarks>
/// <see cref="TestParse"/>と同じデータを使うため、そちらのテストが通っていることを前提とする。
/// </remarks>
- [Test]
+ [TestMethod]
public void TestFilterByNoinclude()
{
IElement element;
}
// noinclude, onlyincludeが展開され、includeonly, コメントが削除される
- Assert.IsInstanceOf(typeof(ListElement), element);
+ Assert.IsInstanceOfType(element, typeof(ListElement));
ListElement list = (ListElement)element;
Assert.AreEqual("This template is [[xxx]]<br />\r\n", list[0].ToString());
Assert.AreEqual("<noWiki><nowiki>sample</nowiki>", list[1].ToString());
Assert.AreEqual(9, list.Count);
// 各要素の確認
- Assert.IsInstanceOf(typeof(TextElement), list[0]);
- Assert.IsInstanceOf(typeof(XmlElement), list[1]);
+ Assert.IsInstanceOfType(list[0], typeof(TextElement));
+ Assert.IsInstanceOfType(list[1], typeof(XmlElement));
// noinclude, onlyincludeはListElementに置き換わる
- Assert.IsInstanceOf(typeof(ListElement), list[4]);
+ Assert.IsInstanceOfType(list[4], typeof(ListElement));
innerList = (ListElement)list[4];
Assert.AreEqual("[[ja:Template:sample/doc]]", innerList[0].ToString());
- Assert.IsInstanceOf(typeof(TextElement), innerList[0]);
+ Assert.IsInstanceOfType(innerList[0], typeof(TextElement));
Assert.AreEqual(1, innerList.Count);
- Assert.IsInstanceOf(typeof(ListElement), list[6]);
+ Assert.IsInstanceOfType(list[6], typeof(ListElement));
innerList = (ListElement)list[6];
Assert.AreEqual("インクルード時は", innerList[0].ToString());
- Assert.IsInstanceOf(typeof(ListElement), innerList[0]);
+ Assert.IsInstanceOfType(innerList[0], typeof(ListElement));
Assert.AreEqual("ここしか", innerList[1].ToString());
- Assert.IsInstanceOf(typeof(TextElement), innerList[1]);
+ Assert.IsInstanceOfType(innerList[1], typeof(TextElement));
Assert.AreEqual(2, innerList.Count);
}
/// <summary>
/// <see cref="MediaWikiPreparser.FilterByNoinclude"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestFilterByNoincludeNull()
{
/// <summary>
/// <see cref="MediaWikiPreparser.PreprocessByInclude"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestPreprocessByInclude()
{
// Parse→FilterByIncludeした結果をToStringしたものが返る
Assert.AreEqual(
"ここしか有効にならない",
MediaWikiPreparser.PreprocessByInclude(TestData));
- Assert.AreEqual(String.Empty, MediaWikiPreparser.PreprocessByInclude(String.Empty));
+ Assert.AreEqual(string.Empty, MediaWikiPreparser.PreprocessByInclude(string.Empty));
}
/// <summary>
/// <see cref="MediaWikiPreparser.PreprocessByInclude"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestPreprocessByIncludeNull()
{
/// <summary>
/// <see cref="MediaWikiPreparser.PreprocessByNoinclude"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestPreprocessByNoinclude()
{
// Parse→FilterByNoincludeした結果をToStringしたものが返る
"This template is [[xxx]]<br />\r\n<noWiki><nowiki>sample</nowiki></nowiki>\r\n\r\n"
+ "[[ja:Template:sample/doc]]\r\nインクルード時はここしか, 有効にならない",
MediaWikiPreparser.PreprocessByNoinclude(TestData));
- Assert.AreEqual(String.Empty, MediaWikiPreparser.PreprocessByNoinclude(String.Empty));
+ Assert.AreEqual(string.Empty, MediaWikiPreparser.PreprocessByNoinclude(string.Empty));
}
/// <summary>
/// <see cref="MediaWikiPreparser.PreprocessByNoinclude"/>メソッドテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestPreprocessByNoincludeNull()
{
using Honememo.Parsers;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiRedirectParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiRedirectParserTest
{
#region ITextParserインタフェース実装メソッド
/// <summary>
/// <see cref="MediaWikiRedirectParser.TryParseToEndCondition"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseToEndCondition()
{
IElement element;
using (MediaWikiRedirectParser parser = new MediaWikiRedirectParser(new MockFactory().GetMediaWiki("en")))
{
// 通常のリダイレクト
- Assert.IsTrue(parser.TryParseToEndCondition("#redirect [[Test]]", null, out element));
- Assert.IsInstanceOf(typeof(MediaWikiLink), element);
+ Assert.IsTrue(parser.TryParseToEndCondition("#redirect [[TestMethod]]", null, out element));
+ Assert.IsInstanceOfType(element, typeof(MediaWikiLink));
link = (MediaWikiLink)element;
Assert.AreEqual("Test", link.Title);
Assert.IsNull(link.Section);
// セクション指定付きのリダイレクト
Assert.IsTrue(parser.TryParseToEndCondition("#redirect [[Test#Section]]", null, out element));
- Assert.IsInstanceOf(typeof(MediaWikiLink), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiLink));
link = (MediaWikiLink)element;
Assert.AreEqual("Test", link.Title);
Assert.AreEqual("Section", link.Section);
// リダイレクトの前にスペースや空行があってもOK
Assert.IsTrue(parser.TryParseToEndCondition(" \r\n \r\n#REDIRECT [[ Test2 ]] \r\n \r\n", null, out element));
- Assert.IsInstanceOf(typeof(MediaWikiLink), element);
+ Assert.IsInstanceOfType(element, typeof(MediaWikiLink));
link = (MediaWikiLink)element;
Assert.AreEqual("Test2", link.Title);
Assert.IsNull(link.Section);
Assert.IsNull(element);
// enで日本語の転送書式
- Assert.IsFalse(parser.TryParseToEndCondition("#転送 [[Test]]", null, out element));
+ Assert.IsFalse(parser.TryParseToEndCondition("#転送 [[TestMethod]]", null, out element));
Assert.IsNull(element);
// 空文字列・null
- Assert.IsFalse(parser.TryParseToEndCondition(String.Empty, null, out element));
+ Assert.IsFalse(parser.TryParseToEndCondition(string.Empty, null, out element));
Assert.IsNull(element);
Assert.IsFalse(parser.TryParseToEndCondition(null, null, out element));
Assert.IsNull(element);
using (MediaWikiRedirectParser parser = new MediaWikiRedirectParser(new MockFactory().GetMediaWiki("ja")))
{
// jaで日本語の転送書式
- Assert.IsTrue(parser.TryParseToEndCondition("#転送 [[Test]]", null, out element));
- Assert.IsInstanceOf(typeof(MediaWikiLink), element);
+ Assert.IsTrue(parser.TryParseToEndCondition("#転送 [[TestMethod]]", null, out element));
+ Assert.IsInstanceOfType(element, typeof(MediaWikiLink));
link = (MediaWikiLink)element;
Assert.AreEqual("Test", link.Title);
}
/// <see cref="MediaWikiRedirectParser.TryParseToEndCondition"/>
/// メソッドテストケース（Dispose）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public void TestTryParseToEndConditionDispose()
{
MediaWikiRedirectParser parser = new MediaWikiRedirectParser(new MockFactory().GetMediaWiki("en"));
parser.Dispose();
IElement result;
- parser.TryParseToEndCondition(String.Empty, null, out result);
+ parser.TryParseToEndCondition(string.Empty, null, out result);
}
#endregion
using Honememo.Parsers;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiTemplateParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiTemplateParserTest
{
#region private変数
/// <summary>
/// 前処理・後処理で生成／解放される言語別の<see cref="MediaWikiParser"/>。
/// </summary>
- private IDictionary<string, MediaWikiParser> mediaWikiParsers = new Dictionary<string, MediaWikiParser>();
+ private static IDictionary<string, MediaWikiParser> mediaWikiParsers = new Dictionary<string, MediaWikiParser>();
#endregion
/// <summary>
/// テストの前処理。
/// </summary>
+ /// <param name="context">テスト用情報。</param>
/// <remarks><see cref="MediaWikiParser.Dispose"/>が必要な<see cref="MediaWikiParser"/>の生成。</remarks>
- [TestFixtureSetUp]
- public void SetUpBeforeClass()
+ [ClassInitialize]
+ public static void SetUpBeforeClass(TestContext context)
{
- this.mediaWikiParsers["en"] = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
- this.mediaWikiParsers["ja"] = new MediaWikiParser(new MockFactory().GetMediaWiki("ja"));
+ mediaWikiParsers["en"] = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
+ mediaWikiParsers["ja"] = new MediaWikiParser(new MockFactory().GetMediaWiki("ja"));
}
/// <summary>
/// テストの後処理。
/// </summary>
/// <remarks><see cref="MediaWikiParser.Dispose"/>が必要な<see cref="MediaWikiParser"/>の解放。</remarks>
- [TestFixtureTearDown]
- public void TearDownAfterClass()
+ [ClassCleanup]
+ public static void TearDownAfterClass()
{
- foreach (IDisposable parser in this.mediaWikiParsers.Values)
+ foreach (IDisposable parser in mediaWikiParsers.Values)
{
parser.Dispose();
}
- this.mediaWikiParsers.Clear();
+ mediaWikiParsers.Clear();
}
#endregion
/// <summary>
/// <see cref="MediaWikiTemplateParser.TryParse"/>メソッドテストケース（基本的な構文）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseBasic()
{
IElement element;
MediaWikiTemplate template;
- MediaWikiTemplateParser parser = new MediaWikiTemplateParser(this.mediaWikiParsers["en"]);
+ MediaWikiTemplateParser parser = new MediaWikiTemplateParser(mediaWikiParsers["en"]);
// タイトルのみ
Assert.IsTrue(parser.TryParse("{{testtitle}}", out element));
/// <summary>
/// <see cref="MediaWikiTemplateParser.TryParse"/>メソッドテストケース（NGパターン）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNg()
{
IElement element;
- MediaWikiTemplateParser parser = new MediaWikiTemplateParser(this.mediaWikiParsers["en"]);
+ MediaWikiTemplateParser parser = new MediaWikiTemplateParser(mediaWikiParsers["en"]);
// 開始タグが無い
Assert.IsFalse(parser.TryParse("testtitle}}", out element));
Assert.IsFalse(parser.TryParse("{{test}title}}", out element));
// 空・null
- Assert.IsFalse(parser.TryParse(String.Empty, out element));
+ Assert.IsFalse(parser.TryParse(string.Empty, out element));
Assert.IsFalse(parser.TryParse(null, out element));
// テンプレート名が無い
/// <summary>
/// <see cref="MediaWikiTemplateParser.TryParse"/>メソッドテストケース（入れ子）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNested()
{
IElement element;
MediaWikiTemplate template;
- MediaWikiTemplateParser parser = new MediaWikiTemplateParser(this.mediaWikiParsers["ja"]);
+ MediaWikiTemplateParser parser = new MediaWikiTemplateParser(mediaWikiParsers["ja"]);
// 入れ子もあり
Assert.IsTrue(parser.TryParse("{{outertemplate|test=[[innerlink]]{{innertemplate}}}}", out element));
Assert.AreEqual("outertemplate", template.Title);
Assert.AreEqual(1, template.PipeTexts.Count);
Assert.AreEqual("test=[[innerlink]]{{innertemplate}}", template.PipeTexts[0].ToString());
- Assert.IsInstanceOf(typeof(ListElement), template.PipeTexts[0]);
+ Assert.IsInstanceOfType(template.PipeTexts[0], typeof(ListElement));
ListElement list = (ListElement)template.PipeTexts[0];
Assert.AreEqual(3, list.Count);
Assert.AreEqual("test=", list[0].ToString());
/// <summary>
/// <see cref="MediaWikiTemplateParser.TryParse"/>メソッドテストケース（サブページ）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseSubpage()
{
IElement element;
MediaWikiTemplate template;
- MediaWikiTemplateParser parser = new MediaWikiTemplateParser(this.mediaWikiParsers["en"]);
+ MediaWikiTemplateParser parser = new MediaWikiTemplateParser(mediaWikiParsers["en"]);
// 全て指定されているケースは通常の記事と同じ扱い
Assert.IsTrue(parser.TryParse("{{testtitle/subpage}}", out element));
/// <see cref="MediaWikiTemplateParser.TryParse"/>メソッドテストケース（実データ複雑なinfobox）。
/// </summary>
/// <remarks>使用データは[[:en:Discovery Channel]]（2012年1月17日 14:07:11(UTC)）より抜粋。</remarks>
- [Test]
+ [TestMethod]
public void TestTryParseInfoboxTvChannel()
{
IElement element;
MediaWikiTemplate template;
- MediaWikiTemplateParser parser = new MediaWikiTemplateParser(this.mediaWikiParsers["en"]);
+ MediaWikiTemplateParser parser = new MediaWikiTemplateParser(mediaWikiParsers["en"]);
// 全て指定されているケースは通常の記事と同じ扱い
Assert.IsTrue(parser.TryParse(
/// Ver 1.11にて無限ループの不具合が発生していたデータ。
/// 中身についてはほぼ処理できない類のものだが、無限ループにならないことだけ検証。
/// </remarks>
- [Test, Timeout(10000)]
+ [TestMethod, Timeout(10000)]
public void TestTryParseTemplateContext()
{
IElement element;
MediaWikiTemplate template;
- MediaWikiTemplateParser parser = new MediaWikiTemplateParser(this.mediaWikiParsers["en"]);
+ MediaWikiTemplateParser parser = new MediaWikiTemplateParser(mediaWikiParsers["en"]);
// テンプレートではなくスクリプトだが、このパーサーで解析される対象ではあるため
Assert.IsTrue(parser.TryParse(
{
using System;
using Honememo.Parsers;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// MediaWikiTemplateのテストクラスです。
+ /// <see cref="MediaWikiTemplate"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class MediaWikiTemplateTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
MediaWikiTemplate element = new MediaWikiTemplate("テンプレート名");
/// <summary>
/// コンストラクタテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorNull()
{
/// <summary>
/// コンストラクタテストケース（空白）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestConstructorBlank()
{
/// <summary>
/// Titleプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTitle()
{
MediaWikiTemplate element = new MediaWikiTemplate("テンプレート名");
/// <summary>
/// Titleプロパティテストケース（空白）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestTitleBlank()
{
/// <summary>
/// IsMsgnwプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsMsgnw()
{
MediaWikiTemplate element = new MediaWikiTemplate("テンプレート名");
/// <summary>
/// NewLineプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNewLine()
{
MediaWikiTemplate element = new MediaWikiTemplate("テンプレート名");
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
MediaWikiTemplate element = new MediaWikiTemplate("テンプレート名");
using Honememo.Parsers;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Websites;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiVariableParser"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiVariableParserTest
{
#region private変数
/// <summary>
/// 前処理・後処理で生成／解放される言語別の<see cref="MediaWikiParser"/>。
/// </summary>
- private IDictionary<string, MediaWikiParser> mediaWikiParsers = new Dictionary<string, MediaWikiParser>();
+ private static IDictionary<string, MediaWikiParser> mediaWikiParsers = new Dictionary<string, MediaWikiParser>();
#endregion
/// <summary>
/// テストの前処理。
/// </summary>
+ /// <param name="context">テスト用情報。</param>
/// <remarks><see cref="MediaWikiParser.Dispose"/>が必要な<see cref="MediaWikiParser"/>の生成。</remarks>
- [TestFixtureSetUp]
- public void SetUpBeforeClass()
+ [ClassInitialize]
+ public static void SetUpBeforeClass(TestContext context)
{
- this.mediaWikiParsers["en"] = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
- this.mediaWikiParsers["ja"] = new MediaWikiParser(new MockFactory().GetMediaWiki("ja"));
+ mediaWikiParsers["en"] = new MediaWikiParser(new MockFactory().GetMediaWiki("en"));
+ mediaWikiParsers["ja"] = new MediaWikiParser(new MockFactory().GetMediaWiki("ja"));
}
/// <summary>
/// テストの後処理。
/// </summary>
/// <remarks><see cref="MediaWikiParser.Dispose"/>が必要な<see cref="MediaWikiParser"/>の解放。</remarks>
- [TestFixtureTearDown]
- public void TearDownAfterClass()
+ [ClassCleanup]
+ public static void TearDownAfterClass()
{
- foreach (IDisposable parser in this.mediaWikiParsers.Values)
+ foreach (IDisposable parser in mediaWikiParsers.Values)
{
parser.Dispose();
}
- this.mediaWikiParsers.Clear();
+ mediaWikiParsers.Clear();
}
#endregion
/// <summary>
/// <see cref="MediaWikiVariableParser.TryParse"/>メソッドテストケース（基本的な構文）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseBasic()
{
IElement element;
MediaWikiVariable variable;
- MediaWikiVariableParser parser = new MediaWikiVariableParser(this.mediaWikiParsers["en"]);
+ MediaWikiVariableParser parser = new MediaWikiVariableParser(mediaWikiParsers["en"]);
// 変数のみ
Assert.IsTrue(parser.TryParse("{{{変数名}}}", out element));
variable = (MediaWikiVariable)element;
Assert.AreEqual("変数名", variable.Variable);
Assert.IsNotNull(variable.Value);
- Assert.IsEmpty(variable.Value.ToString());
+ Assert.AreEqual(string.Empty, variable.Value.ToString());
// コメントについてはあっても特に問題ない
Assert.IsTrue(parser.TryParse("{{{変数名<!--必要に応じて変更1-->|デフォルト値<!--必要に応じて変更2-->}}}", out element));
/// <summary>
/// <see cref="MediaWikiVariableParser.TryParse"/>メソッドテストケース（NGパターン）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNg()
{
IElement element;
- MediaWikiVariableParser parser = new MediaWikiVariableParser(this.mediaWikiParsers["en"]);
+ MediaWikiVariableParser parser = new MediaWikiVariableParser(mediaWikiParsers["en"]);
// 開始タグが無い
Assert.IsFalse(parser.TryParse("変数名}}}", out element));
Assert.IsFalse(parser.TryParse("{{変数名}}", out element));
// 空・null
- Assert.IsFalse(parser.TryParse(String.Empty, out element));
+ Assert.IsFalse(parser.TryParse(string.Empty, out element));
Assert.IsFalse(parser.TryParse(null, out element));
}
/// <summary>
/// <see cref="MediaWikiVariableParser.TryParse"/>メソッドテストケース（入れ子）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTryParseNested()
{
IElement element;
MediaWikiVariable variable;
- MediaWikiVariableParser parser = new MediaWikiVariableParser(this.mediaWikiParsers["ja"]);
+ MediaWikiVariableParser parser = new MediaWikiVariableParser(mediaWikiParsers["ja"]);
// 入れ子もあり
Assert.IsTrue(parser.TryParse("{{{変数名|[[内部リンク]]{{ref-en}}}}}", out element));
variable = (MediaWikiVariable)element;
Assert.AreEqual("変数名", variable.Variable);
Assert.AreEqual("[[内部リンク]]{{ref-en}}", variable.Value.ToString());
- Assert.IsInstanceOf(typeof(ListElement), variable.Value);
+ Assert.IsInstanceOfType(variable.Value, typeof(ListElement));
ListElement list = (ListElement)variable.Value;
Assert.AreEqual(2, list.Count);
- Assert.IsInstanceOf(typeof(MediaWikiLink), list[0]);
+ Assert.IsInstanceOfType(list[0], typeof(MediaWikiLink));
Assert.AreEqual("[[内部リンク]]", list[0].ToString());
- Assert.IsInstanceOf(typeof(MediaWikiTemplate), list[1]);
+ Assert.IsInstanceOfType(list[1], typeof(MediaWikiTemplate));
Assert.AreEqual("{{ref-en}}", list[1].ToString());
}
{
using System;
using Honememo.Parsers;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// MediaWikiVariableのテストクラスです。
+ /// <see cref="MediaWikiVariable"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
public class MediaWikiVariableTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructor()
{
MediaWikiVariable element;
/// <summary>
/// Variableプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestVariable()
{
MediaWikiVariable element = new MediaWikiVariable("変数名");
/// <summary>
/// Valueプロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestValue()
{
MediaWikiVariable element = new MediaWikiVariable("変数名");
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
MediaWikiVariable element = new MediaWikiVariable("変数名");
// ================================================================================================
// <summary>
-// NUnitテスト支援用クラスソース。</summary>
+// ユニットテスト支援用クラスソース。</summary>
//
// <copyright file="PrivateAccessor.cs" company="honeplusのメモ帳">
// Copyright (C) 2012 Honeplus. All rights reserved.</copyright>
using System;
using System.Collections.Generic;
using System.Reflection;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// NUnitでのテスト用に private, protected といった外部からアクセスできないメソッドを実行するためのクラス。
+ /// ユニットテスト用に private, protected といった外部からアクセスできないメソッドを実行するためのクラス。
/// クラス・オブジェクトに被せるように使用する。
/// </summary>
/// <typeparam name="T">ラップするオブジェクトのクラス。</typeparam>
using System.IO;
using Honememo.Wptscs.Properties;
using Honememo.Wptscs.Utilities;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="AppConfigWebProxy"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class AppConfigWebProxyTest
{
#region 定数
/// <summary>
/// テストデータが格納されているフォルダパス。
/// </summary>
- private static readonly string testFile = "Data\\config.xml";
+ private static readonly string TestFile = "Data\\config.xml";
#endregion
/// <see cref="AppConfigWebProxy.UserAgent"/>プロパティテストケース。
/// </summary>
/// <remarks>アプリ設定部分はアクセス権の関係上試験できず。</remarks>
- [Test]
+ [TestMethod]
public void TestUserAgent()
{
IWebProxy proxy = new AppConfigWebProxy();
- ////Settings.Default.UserAgent = String.Empty;
+ ////Settings.Default.UserAgent = string.Empty;
// 初期状態ではアプリ名を元に生成した値
Version ver = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
//// String.Format(Settings.Default.DefaultUserAgent, ver.Major, ver.Minor),
//// proxy.UserAgent);
Assert.AreEqual(
- String.Format("Translation Support for Wikipedia/{0}.{1:D2}", ver.Major, ver.Minor),
+ string.Format("Translation Support for Wikipedia/{0}.{1:D2}", ver.Major, ver.Minor),
proxy.UserAgent);
// プロパティ設定時はその値が返る
Assert.AreEqual("test property useragent", proxy.UserAgent);
// 空でも有効
- proxy.UserAgent = String.Empty;
- Assert.IsEmpty(proxy.UserAgent);
+ proxy.UserAgent = string.Empty;
+ Assert.AreEqual(string.Empty, proxy.UserAgent);
// nullなら無効
proxy.UserAgent = null;
- Assert.IsNotEmpty(proxy.UserAgent);
+ Assert.IsTrue(proxy.UserAgent.Length > 0);
// アプリ設定時はアプリに格納された設定値が最優先
////Settings.Default.UserAgent = "test setting useragent";
/// <see cref="AppConfigWebProxy.Referer"/>プロパティテストケース。
/// </summary>
/// <remarks>アプリ設定部分はアクセス権の関係上試験できず。</remarks>
- [Test]
+ [TestMethod]
public void TestReferer()
{
IWebProxy proxy = new AppConfigWebProxy();
- ////Settings.Default.Referer = String.Empty;
+ ////Settings.Default.Referer = string.Empty;
// 初期状態では空
- Assert.IsEmpty(proxy.Referer);
+ Assert.AreEqual(string.Empty, proxy.Referer);
// プロパティ設定時はその値が返る
proxy.Referer = "test property referer";
/// <see cref="AppConfigWebProxy.GetStream"/>メソッドテストケース。
/// </summary>
/// <remarks>内容的に難しいため、fileプロトコルのみ確認。</remarks>
- [Test]
+ [TestMethod]
public void TestGetStream()
{
IWebProxy proxy = new AppConfigWebProxy();
// テストファイルを読んで例外が発生しなければOKとする
- UriBuilder b = new UriBuilder("file", String.Empty);
- b.Path = Path.GetFullPath(testFile);
+ UriBuilder b = new UriBuilder("file", string.Empty);
+ b.Path = Path.GetFullPath(TestFile);
using (proxy.GetStream(b.Uri))
{
}
using System;
using System.Windows.Forms;
using Honememo.Wptscs.Utilities;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
- /// FormUtilsのテストクラスです。
+ /// <see cref="FormUtils"/>のテストクラスです。
/// </summary>
/// <remarks>
/// その性質上、画面周りのメソッドならびに設定ファイル関連のメソッドについてはテストケースが作成できていない。
/// これらのメソッドに手を入れる際は注意すること。
/// </remarks>
- [TestFixture]
+ [TestClass]
public class FormUtilsTest
{
+ #region private変数
+
+ /// <summary>
+ /// テスト実施中カルチャを変更し後で戻すため、そのバックアップ。
+ /// </summary>
+ private System.Globalization.CultureInfo backupCulture;
+
+ #endregion
+
+ #region 前処理・後処理
+
+ /// <summary>
+ /// テストの前処理。
+ /// </summary>
+ [TestInitialize]
+ public void SetUp()
+ {
+ // 一部処理結果はカルチャーにより変化するため、ja-JPを明示的に設定する
+ this.backupCulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
+ System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.GetCultureInfo("ja-JP");
+ }
+
+ /// <summary>
+ /// テストの後処理。
+ /// </summary>
+ [TestCleanup]
+ public void TearDown()
+ {
+ // カルチャーを元に戻す
+ System.Threading.Thread.CurrentThread.CurrentUICulture = this.backupCulture;
+ }
+
+ #endregion
+
#region リソース関連テストケース
/// <summary>
/// ReplaceInvalidFileNameCharsメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestApplicationName()
{
// ※ バージョンが変わるごとにバージョン表記の部分を書き換えるのは面倒なので置換
/// <summary>
/// ReplaceInvalidFileNameCharsメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReplaceInvalidFileNameChars()
{
Assert.AreEqual("C__test_test.doc", FormUtils.ReplaceInvalidFileNameChars("C:\\test\\test.doc"));
/// <summary>
/// ToStringメソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestToString()
{
// 引数二つ
Assert.AreNotEqual("null", FormUtils.ToString(new DummyCell { Value = new object() }, "null"));
// 引数一つ
- Assert.AreEqual(String.Empty, FormUtils.ToString(null));
- Assert.AreEqual(String.Empty, FormUtils.ToString(new DummyCell()));
+ Assert.AreEqual(string.Empty, FormUtils.ToString(null));
+ Assert.AreEqual(string.Empty, FormUtils.ToString(new DummyCell()));
Assert.AreEqual("not null", FormUtils.ToString(new DummyCell { Value = "not null" }));
- Assert.IsNotEmpty(FormUtils.ToString(new DummyCell { Value = new object() }));
+ Assert.IsTrue(FormUtils.ToString(new DummyCell { Value = new object() }).Length > 0);
}
#endregion
using Honememo.Utilities;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Parsers;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWikiPage"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiPageTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorWebsiteTitleTextTimestamp()
{
DateTime t = DateTime.Now;
/// <summary>
/// コンストラクタテストケース（タイムスタンプ無し）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorWebsiteTitleText()
{
MediaWiki s = new MediaWiki(new Language("en"));
/// <summary>
/// コンストラクタテストケース（本文・タイムスタンプ無し）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorWebsiteTitle()
{
MediaWiki s = new MediaWiki(new Language("en"));
/// <summary>
/// コンストラクタテストケース（ウェブサイトがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorWebsiteNull()
{
/// <summary>
/// コンストラクタテストケース（タイトルが空）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestConstructorTitleBlank()
{
/// <summary>
/// <see cref="MediaWikiPage.Redirect"/>プロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestRedirect()
{
MediaWiki site;
/// <summary>
/// <see cref="MediaWikiPage.Redirect"/>プロパティテストケース（Text未設定）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(InvalidOperationException))]
public void TestRedirectTextNull()
{
/// <summary>
/// <see cref="MediaWikiPage.GetInterlanguage"/>メソッドテストケース（通常ページ）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetInterlanguage()
{
// 普通のページ
/// <summary>
/// <see cref="MediaWikiPage.GetInterlanguage"/>メソッドテストケース（通常ページ実データ使用）。
/// </summary>
- [Test, Timeout(20000)]
+ [TestMethod, Timeout(20000)]
public void TestGetInterlanguageDiscoveryChannel()
{
MediaWikiPage page = (MediaWikiPage)new MockFactory().GetMediaWiki("en").GetPage("Discovery Channel");
/// <summary>
/// <see cref="MediaWikiPage.GetInterlanguage"/>メソッドテストケース（テンプレートページ実データ使用）。
/// </summary>
- [Test, Timeout(20000)]
+ [TestMethod, Timeout(20000)]
public void TestGetInterlanguagePlanetboxBegin()
{
MediaWikiPage page = (MediaWikiPage)new MockFactory().GetMediaWiki("en").GetPage("Template:Planetbox begin");
/// <summary>
/// <see cref="MediaWikiPage.GetInterlanguage"/>メソッドテストケース（Template:Documentation使用ページ）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetInterlanguageDocumentation()
{
// Template:Documentation を使ってるページ
/// <summary>
/// <see cref="MediaWikiPage.GetInterlanguage"/>メソッドテストケース（Template:Documentationにnoincludeで囲まれた言語間リンクが存在）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetInterlanguagePartial()
{
MediaWikiPage page = (MediaWikiPage)new MockFactory().GetMediaWiki("en").GetPage("Template:Partial");
/// <summary>
/// <see cref="MediaWikiPage.IsRedirect"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsRedirect()
{
MediaWiki site = new MediaWiki(new Language("en"));
/// <summary>
/// <see cref="MediaWikiPage.Normalize"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNormalize()
{
MediaWiki site = new MediaWiki(new Language("en"));
/// <summary>
/// <see cref="MediaWikiPage.ValidateIncomplete"/>メソッドテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestValidateIncomplete()
{
// Textが空の場合例外発生、正常系は例外が発生しなければOK
/// <summary>
/// <see cref="MediaWikiPage.ValidateIncomplete"/>メソッドテストケース（異常系）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(InvalidOperationException))]
public void TestValidateIncompleteNg()
{
using Honememo.Models;
using Honememo.Utilities;
using Honememo.Wptscs.Models;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="MediaWiki"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class MediaWikiTest
{
#region 定数
/// <summary>
/// テストデータが格納されているフォルダパス。
/// </summary>
- private static readonly string testDir = "Data\\MediaWiki";
+ private static readonly string TestDir = "Data\\MediaWiki";
/// <summary>
/// XMLインポート／エクスポートで用いるテストデータ。
/// </summary>
- private static readonly string testXml = "<MediaWiki><Location>http://ja.wikipedia.org</Location>"
+ private static readonly string TestXml = "<MediaWiki><Location>http://ja.wikipedia.org</Location>"
+ "<Language Code=\"ja\"><Names /><Bracket /></Language>"
+ "<MetaApi>_api.xml</MetaApi><ExportPath>/export/$1</ExportPath><Redirect>#飛ばす</Redirect>"
+ "<TemplateNamespace>100</TemplateNamespace><CategoryNamespace>101</CategoryNamespace><FileNamespace>200</FileNamespace>"
// ※ 下記URL生成時は、きちんとパス区切り文字を入れてやら無いとフォルダが認識されない。
// また、httpで取得した場合とfileで取得した場合では先頭の大文字小文字が異なることが
// あるため、それについては随時期待値を調整して対処。
- UriBuilder b = new UriBuilder("file", String.Empty);
- b.Path = Path.GetFullPath(testDir) + "\\";
+ UriBuilder b = new UriBuilder("file", string.Empty);
+ b.Path = Path.GetFullPath(TestDir) + "\\";
MediaWiki server = new MediaWiki(new Language(language), new Uri(b.Uri, language + "/").ToString());
server.ExportPath = "$1.xml";
server.MetaApi = "_api.xml";
/// <summary>
/// コンストラクタ（MediaWiki全般）テストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorLanguageLocation()
{
MediaWiki site = new MediaWiki(new Language("en"), "test");
/// <summary>
/// コンストラクタ（MediaWiki全般）テストケース（languageがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorLanguageLocationByLanguageNull()
{
/// <summary>
/// コンストラクタ（MediaWiki全般）テストケース（locationがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorLanguageLocationByLocationNull()
{
/// <summary>
/// コンストラクタ（Wikipedia用）テストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorLanguage()
{
MediaWiki site = new MediaWiki(new Language("en"));
/// <summary>
/// コンストラクタ（Wikipedia用）テストケース（languageがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorLanguageByLanguageNull()
{
/// <summary>
/// <see cref="MediaWiki.MetaApi"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestMetaApi()
{
MediaWiki site = new MediaWiki(new Language("ja"));
// 空またはnullの場合、再び設定ファイルの値が入る
site.MetaApi = null;
Assert.AreEqual("/w/api.php?format=xml&action=query&meta=siteinfo&siprop=namespaces|namespacealiases|interwikimap", site.MetaApi);
- site.MetaApi = String.Empty;
+ site.MetaApi = string.Empty;
Assert.AreEqual("/w/api.php?format=xml&action=query&meta=siteinfo&siprop=namespaces|namespacealiases|interwikimap", site.MetaApi);
}
/// <summary>
/// <see cref="MediaWiki.ExportPath"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestExportPath()
{
MediaWiki site = new MediaWiki(new Language("ja"));
// 空またはnullの場合、再び設定ファイルの値が入る
site.ExportPath = null;
Assert.AreEqual("/wiki/Special:Export/$1", site.ExportPath);
- site.ExportPath = String.Empty;
+ site.ExportPath = string.Empty;
Assert.AreEqual("/wiki/Special:Export/$1", site.ExportPath);
}
/// <summary>
/// <see cref="MediaWiki.Redirect"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestRedirect()
{
MediaWiki site = new MediaWiki(new Language("ja"));
// 空またはnullの場合、再び設定ファイルの値が入る
site.Redirect = null;
Assert.AreEqual("#REDIRECT", site.Redirect);
- site.Redirect = String.Empty;
+ site.Redirect = string.Empty;
Assert.AreEqual("#REDIRECT", site.Redirect);
}
/// <summary>
/// <see cref="MediaWiki.TemplateNamespace"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTemplateNamespace()
{
MediaWiki site = new MediaWiki(new Language("ja"));
/// <summary>
/// <see cref="MediaWiki.CategoryNamespace"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestCategoryNamespace()
{
MediaWiki site = new MediaWiki(new Language("ja"));
/// <summary>
/// <see cref="MediaWiki.FileNamespace"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestFileNamespace()
{
MediaWiki site = new MediaWiki(new Language("ja"));
/// <summary>
/// <see cref="MediaWiki.MagicWords"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestMagicWords()
{
MediaWiki site = new MediaWiki(new Language("ja"));
/// <summary>
/// <see cref="MediaWiki.Namespaces"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestNamespaces()
{
MediaWiki site = this.GetTestServer("en");
/// <summary>
/// <see cref="MediaWiki.InterwikiPrefixs"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestInterwikiPrefixs()
{
MediaWiki site = this.GetTestServer("en");
/// <summary>
/// <see cref="MediaWiki.DocumentationTemplates"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestDocumentationTemplates()
{
MediaWiki site = new MediaWiki(new Language("ja"));
/// <summary>
/// <see cref="MediaWiki.DocumentationTemplateDefaultPage"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestDocumentationTemplateDefaultPage()
{
MediaWiki site = new MediaWiki(new Language("ja"));
// デフォルトでは空
- Assert.IsNullOrEmpty(site.DocumentationTemplateDefaultPage);
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.DocumentationTemplateDefaultPage));
// 値を設定するとその値が返る
site.DocumentationTemplateDefaultPage = "/doc";
Assert.AreEqual("/doc", site.DocumentationTemplateDefaultPage);
site.DocumentationTemplateDefaultPage = null;
- Assert.IsNullOrEmpty(site.DocumentationTemplateDefaultPage);
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.DocumentationTemplateDefaultPage));
}
/// <summary>
/// <see cref="MediaWiki.LinkInterwikiFormat"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestLinkInterwikiFormat()
{
MediaWiki site = new MediaWiki(new Language("ja"));
// デフォルトでは空
- Assert.IsNullOrEmpty(site.LinkInterwikiFormat);
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.LinkInterwikiFormat));
// 値を設定するとその値が返る
site.LinkInterwikiFormat = "{{仮リンク|$1|$2|$3|label=$4}}";
Assert.AreEqual("{{仮リンク|$1|$2|$3|label=$4}}", site.LinkInterwikiFormat);
site.LinkInterwikiFormat = null;
- Assert.IsNullOrEmpty(site.LinkInterwikiFormat);
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.LinkInterwikiFormat));
}
/// <summary>
/// <see cref="MediaWiki.LangFormat"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestLangFormat()
{
MediaWiki site = new MediaWiki(new Language("ja"));
// デフォルトでは空
- Assert.IsNullOrEmpty(site.LangFormat);
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.LangFormat));
// 値を設定するとその値が返る
site.LangFormat = "{{Lang|$1|$2}}";
Assert.AreEqual("{{Lang|$1|$2}}", site.LangFormat);
site.LangFormat = null;
- Assert.IsNullOrEmpty(site.LangFormat);
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.LangFormat));
}
/// <summary>
/// <see cref="MediaWiki.HasLanguagePage"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestHasLanguagePage()
{
MediaWiki site = new MediaWiki(new Language("ja"));
/// <summary>
/// <see cref="MediaWiki.GetPage"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestGetPage()
{
MediaWiki site = this.GetTestServer("en");
Page page = site.GetPage("example");
- Assert.IsInstanceOf(typeof(MediaWikiPage), page);
+ Assert.IsInstanceOfType(page, typeof(MediaWikiPage));
Assert.AreEqual("Example", page.Title);
Assert.AreEqual(DateTime.Parse("2010/07/13 09:49:18"), page.Timestamp);
- Assert.IsNotEmpty(page.Text);
+ Assert.IsTrue(page.Text.Length > 0);
Assert.AreEqual(site, page.Website);
}
/// <summary>
/// <see cref="MediaWiki.IsMagicWord"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsMagicWord()
{
MediaWiki site = new MediaWiki(new Language("en"), "http://example.com");
/// <summary>
/// <see cref="MediaWiki.IsInterwiki"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsInterwiki()
{
MediaWiki site = this.GetTestServer("en");
/// <summary>
/// <see cref="MediaWiki.IsNamespace"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestIsNamespace()
{
MediaWiki site = this.GetTestServer("en");
/// <summary>
/// <see cref="MediaWiki.FormatLinkInterwiki"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestFormatLinkInterwiki()
{
MediaWiki site = new MediaWiki(new Language("en"), "http://example.com");
// LinkInterwikiFormatが空の場合、nullが返る
site.LinkInterwikiFormat = null;
Assert.IsNull(site.FormatLinkInterwiki("記事名", "言語", "他言語版記事名", "表示名"));
- site.LinkInterwikiFormat = String.Empty;
+ site.LinkInterwikiFormat = string.Empty;
Assert.IsNull(site.FormatLinkInterwiki("記事名", "言語", "他言語版記事名", "表示名"));
// 値が設定されている場合、パラメータを埋め込んで書式化される
/// <summary>
/// <see cref="MediaWiki.FormatLang"/>メソッドテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestFormatLang()
{
MediaWiki site = new MediaWiki(new Language("en"), "http://example.com");
// LangFormatが空の場合、nullが返る
site.LangFormat = null;
Assert.IsNull(site.FormatLang("ja", "日本語テキスト"));
- site.LangFormat = String.Empty;
+ site.LangFormat = string.Empty;
Assert.IsNull(site.FormatLang("ja", "日本語テキスト"));
// 値が設定されている場合、パラメータを埋め込んで書式化される
/// <summary>
/// XMLデシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestReadXml()
{
// ほぼ空の状態での読み込み
Assert.AreEqual("http://ja.wikipedia.org", site.Location);
Assert.AreEqual("ja", site.Language.Code);
Assert.AreEqual(0, site.DocumentationTemplates.Count);
- Assert.IsNullOrEmpty(site.DocumentationTemplateDefaultPage);
- Assert.IsNullOrEmpty(site.LinkInterwikiFormat);
- Assert.IsNullOrEmpty(site.LangFormat);
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.DocumentationTemplateDefaultPage));
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.LinkInterwikiFormat));
+ Assert.AreEqual(string.Empty, StringUtils.DefaultString(site.LangFormat));
Assert.IsFalse(site.HasLanguagePage);
// 下記プロパティは、空の場合デフォルト値が返る
Assert.IsTrue(site.MagicWords.Count > 10);
// プロパティに値が設定された状態での読み込み
- using (XmlReader r = XmlReader.Create(new StringReader(testXml)))
+ using (XmlReader r = XmlReader.Create(new StringReader(TestXml)))
{
site = new XmlSerializer(typeof(MediaWiki)).Deserialize(r) as MediaWiki;
}
/// <summary>
/// XMLシリアライズテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWriteXml()
{
MediaWiki site = new MediaWiki(new Language("ja"));
new XmlSerializer(typeof(MediaWiki)).Serialize(w, site);
}
- Assert.AreEqual(testXml, b.ToString());
+ Assert.AreEqual(TestXml, b.ToString());
}
#endregion
using System.Collections.Generic;
using Honememo.Tests;
using Honememo.Utilities;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="Page"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class PageTest
{
#region コンストラクタテストケース
/// <summary>
/// コンストラクタテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorWebsiteTitleTextTimestamp()
{
DateTime t = DateTime.Now;
/// <summary>
/// コンストラクタテストケース（タイムスタンプ無し）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorWebsiteTitleText()
{
Website s = new DummySite();
/// <summary>
/// コンストラクタテストケース（本文・タイムスタンプ無し）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestConstructorWebsiteTitle()
{
Website s = new DummySite();
/// <summary>
/// コンストラクタテストケース（ウェブサイトがnull）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestConstructorWebsiteNull()
{
/// <summary>
/// コンストラクタテストケース（タイトルが空）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestConstructorTitleBlank()
{
/// <summary>
/// <see cref="Page.Website"/>プロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWebsite()
{
Page page = new Page(new DummySite(), "TestTitle");
/// <summary>
/// <see cref="Page.Website"/>プロパティテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestWebsiteNull()
{
/// <summary>
/// <see cref="Page.Title"/>プロパティテストケース（正常系）。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTitle()
{
Page page = new Page(new DummySite(), "TestTitle");
/// <summary>
/// <see cref="Page.Title"/>プロパティテストケース（null値）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestTitleNull()
{
/// <summary>
/// <see cref="Page.Title"/>プロパティテストケース（空）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestTitleBlank()
{
/// <summary>
/// <see cref="Page.Text"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestText()
{
Page page = new Page(new DummySite(), "TestTitle");
/// <summary>
/// <see cref="Page.Timestamp"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestTimestamp()
{
Page page = new Page(new DummySite(), "TestTitle");
/// <summary>
/// <see cref="Page.Uri"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestUri()
{
Page page = new Page(new DummySite(), "TestTitle");
using System;
using Honememo.Wptscs.Models;
using Honememo.Wptscs.Utilities;
- using NUnit.Framework;
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
/// <summary>
/// <see cref="Website"/>のテストクラスです。
/// </summary>
- [TestFixture]
+ [TestClass]
internal class WebsiteTest
{
#region プロパティテストケース
/// <summary>
/// <see cref="Website.Location"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestLocation()
{
DummySite site = new DummySite();
/// <summary>
/// <see cref="Website.Location"/>プロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestLocationNull()
{
/// <summary>
/// <see cref="Website.Location"/>プロパティテストケース（空）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestLocationBlank()
{
/// <summary>
/// <see cref="Website.Language"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestLanguage()
{
DummySite site = new DummySite();
/// <summary>
/// <see cref="Website.Language"/>プロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestLanguageNull()
{
/// <summary>
/// <see cref="Website.WebProxy"/>プロパティテストケース。
/// </summary>
- [Test]
+ [TestMethod]
public void TestWebProxy()
{
DummySite site = new DummySite();
/// <summary>
/// <see cref="Website.WebProxy"/>プロパティテストケース（null）。
/// </summary>
- [Test]
+ [TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void TestWebProxyNull()
{
<AssemblyName>WptscsTest</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
- <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+ <TargetFrameworkProfile>
+ </TargetFrameworkProfile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
- <StartAction>Program</StartAction>
- <StartProgram>$(ProgramFiles)\NUnit 2.5.5\bin\net-2.0\nunit.exe</StartProgram>
<DocumentationFile>bin\Debug\WptscsTest.XML</DocumentationFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
- <Reference Include="nunit.framework, Version=2.5.5.10112, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
+ <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
<Reference Include="System" />
<Reference Include="System.Windows.Forms" />
<Reference Include="System.XML" />
</None>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
- <Import Project="$(ProgramFiles)\MSBuild\Microsoft\StyleCop\v4.4\Microsoft.StyleCop.Targets" />
+ <Import Project="$(ProgramFiles)\MSBuild\StyleCop\v4.7\StyleCop.Targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
OSDN Git Service
