public void WhenTestCaseCompletes_NodeShowsProperResult(ResultState resultState, int expectedIndex)
{
_model.IsPackageLoaded.Returns(true);
_model.HasTests.Returns(true);
_view.DisplayFormat.SelectedItem.Returns("NUNIT_TREE");
var result = resultState.Status.ToString();
var label = resultState.Label;
var doc = new XmlDocument();
if (string.IsNullOrEmpty(label))
doc.LoadXml(string.Format("<test-run id='1'><test-case id='123' result='{0}'/></test-run>", result));
else
doc.LoadXml(string.Format("<test-run id='1'><test-case id='123' result='{0}' label='{1}'/></test-run>", result, label));
var testNode = new TestNode(doc.FirstChild);
_model.Tests.Returns(testNode);
//var treeNode = _adapter.MakeTreeNode(result);
//_adapter.NodeIndex[suiteResult.Id] = treeNode;
_model.TestLoaded += Raise.Event<TestEventHandler>(new TestEventArgs(TestAction.TestLoaded, testNode));
_model.TestFinished += Raise.Event<TestEventHandler>(new TestEventArgs(TestAction.TestFinished, testNode.Children[0]));
_view.Tree.Received().SetImageIndex(Arg.Any<TreeNode>(), expectedIndex);
}
public static void IsRunnable(Type type, string name, ResultState resultState)
{
Test test = TestBuilder.MakeTestCase(type, name);
Assert.That(test.RunState, Is.EqualTo(RunState.Runnable));
TestResult result = test.Run(NullListener.NULL, TestFilter.Empty);
if (result.HasResults)
result = (TestResult)result.Results[0];
Assert.That(result.ResultState, Is.EqualTo(resultState));
}
public void RunTests(MethodInfo testMethod, ResultState resultState, int assertionCount)
{
var method = _builder.BuildFrom(testMethod);
var result = method.Run(new NullListener(), TestFilter.Empty);
Assert.That(result.Executed, Is.True, "Was not executed");
Assert.That(result.ResultState, Is.EqualTo(resultState), "Wrong result state");
Assert.That(result.AssertCount, Is.EqualTo(assertionCount), "Wrong assertion count");
}
public void WhenResultIsSet_IndexReflectsResultState(ResultState resultState, int expectedIndex)
{
TestSuiteTreeNode node = new TestSuiteTreeNode(new TestInfo(testCase));
TestResult result = new TestResult(testCase);
result.SetResult(resultState, null, null);
node.Result = result;
Assert.AreEqual(expectedIndex, node.ImageIndex);
Assert.AreEqual(expectedIndex, node.SelectedImageIndex);
Assert.AreEqual(resultState.ToString(), node.StatusText);
}
void VerifyResultState(ResultState expectedState, bool executed, bool success, bool failure, bool error, string message )
{
Assert.That( result.ResultState , Is.EqualTo( expectedState ) );
Assert.That( result.Executed, Is.EqualTo( executed ) );
Assert.That( result.IsSuccess, Is.EqualTo( success ) );
Assert.That( result.IsFailure, Is.EqualTo( failure ) );
Assert.That( result.IsError, Is.EqualTo( error ) );
if ( error )
Assert.That(result.Message, Is.EqualTo("System.Exception : " + message));
else
Assert.That(result.Message, Is.EqualTo(message));
}
string GetTestResultMessageForResultState(TestResult testResult, ResultState state, string heading)
{
var messageBuilder = new StringBuilder();
for (var i = 0; i < testResult.Results.Count; i++)
{
var result = (TestResult) testResult.Results[i];
if (result.ResultState == state)
{
messageBuilder.AppendLine(string.Format("{0} for specification {1}", heading, i + 1));
messageBuilder.AppendLine(result.Message);
}
}
return messageBuilder.ToString();
}
public void RunnerTest(string commandLineArguments, ResultState expectedResultValidate, ResultState expectedResultRun, ParserNotation notation)
{
var configuration = new CommandConfiguration();
configuration.CommandAssemblies.Add(Assembly.GetExecutingAssembly());
var runner = new CommandRunner(new CommandParser(notation), new CommandLookup(configuration));
var result1 = runner.Validate(commandLineArguments);
var result2 = runner.Run(commandLineArguments);
// Assert
Assert.NotNull(result1);
Assert.NotNull(result2);
Assert.True(result1.State == expectedResultValidate);
Assert.True(result2.State == expectedResultRun);
Assert.NotNull(result1.CommandInfo);
}
private Image ImageResult(ResultState resState)
{
Image image = new Image();
if (resState.Equals(ResultState.Success))
{
image.ImageUrl = "~/img/passed.png";
}
else if (resState.Equals(ResultState.Ignored))
{
image.ImageUrl = "~/img/Ignored.png";
}
else
{
image.ImageUrl = "~/img/failed.png";
}
return image;
}
public TestResult CreateTestResult(TestType type, string fullName,
ResultState state = ResultState.Success,
Func<IEnumerable<TestResult>> children = null,
string stackTrace = null,
string description = null,
IList categories = null,
string agentName = null)
{
description = description ?? RandomValuesGenerator.GetRandomValue<string>();
agentName = agentName ?? RandomValuesGenerator.GetRandomValue<string>();
var splitted = (fullName ?? string.Empty).Split(new[]{'.'}, StringSplitOptions.RemoveEmptyEntries);
var childResults = children != null ? children() : new TestResult[0];
var testResult = new TestResult(new TestInfoWrapper
{
TestName = new TestName
{
FullName = fullName,
Name = splitted.Length > 0 ? splitted[splitted.Length - 1] : string.Empty
},
Categories = categories,
IsSuite = type != TestType.TestMethod,
TestCount = type == TestType.TestMethod ? 1 : RandomValuesGenerator.GetRandomValue<int>(),
TestType = type.ToString()
})
{
AssertCount = 1,
Time = RandomValuesGenerator.GetRandomValue<double>()
};
if (state != ResultState.Success)
testResult.SetResult(state,
description,
stackTrace);
else
testResult.Success(description);
testResult.SetAgentName(agentName);
foreach (var childResult in childResults)
{
testResult.AddResult(childResult);
}
return testResult;
}
public ResultState <TItem> Compile <TItem>(TableIdentity heading)
{
ResultBuilder builder = new ResultBuilder(this.State, heading);
ResultNode result = builder.Build();
ContractValidator.Validate(result);
ResultState <TItem> factory = new ResultState <TItem>()
{
Aggregate = this.State.Aggregate,
Item = this.CompileForEnumerate <TItem>(heading),
Initializer = this.CompileForInitializer(result),
List = this.CompileForList(result),
ListItem = this.CompileForListItem(result),
};
return(factory);
}
// This could be any kind of request handler. Details aren't that important.
public string GetResults(string[] requestData)
{
// Do some processing.
ResultState state = DoSomeWorkUntrusted();
// Since any value can be cast to an enum, we use a Try pattern to ensure this is a valid enum.
string resultString;
if (EnumManager <ResultState> .TryGetString(state, out resultString))
{
return(resultString);
}
else
{
// DoSomeWork may not be trusted to return a valid value, handle its error here.
return("Unable to parse");
}
}
/// <summary>
/// Set the result of the test
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="message">A message associated with the result state</param>
/// <param name="stackTrace">Stack trace giving the location of the command</param>
public void SetResult(ResultState resultState, string message, string stackTrace)
{
#if PARALLEL
RwLock.EnterWriteLock();
#endif
try
{
ResultState = resultState;
Message = message;
StackTrace = stackTrace;
}
finally
{
#if PARALLEL
RwLock.ExitWriteLock();
#endif
}
}
private void SkipChildren(TestSuite suite, ResultState resultState, string message)
{
// TODO: Extend this to skip recursively?
foreach (Test child in suite.Tests)
{
if (_childFilter.Pass(child))
{
TestResult childResult = child.MakeTestResult();
childResult.SetResult(resultState, message);
Result.AddResult(childResult);
if (child.IsSuite)
{
SkipChildren((TestSuite)child, resultState, message);
}
}
}
}
private void SkipChildren(TestSuite suite, ResultState resultState, string message)
{
foreach (Test child in suite.Tests)
{
if (_childFilter.Pass(child))
{
Context.Listener.TestStarted(child);
TestResult childResult = child.MakeTestResult();
childResult.SetResult(resultState, message);
_suiteResult.AddResult(childResult);
if (child.IsSuite)
SkipChildren((TestSuite)child, resultState, message);
Context.Listener.TestFinished(childResult);
}
}
}
public override void Process()
{
try
{
Start = String.IsNullOrEmpty(Request["start"]) ? 0 : Convert.ToInt32(Request["start"]);
Size = String.IsNullOrEmpty(Request["size"]) ? Config.GetInt("imageManagerListSize") : Convert.ToInt32(Request["size"]);
}
catch (FormatException)
{
State = ResultState.InvalidParam;
WriteResult();
return;
}
var buildingList = new List<String>();
try
{
var localPath = Server.MapPath(PathToList);
var allFiles = Directory.GetFiles(localPath, "*", SearchOption.AllDirectories)
.Where(x => SearchExtensions.Contains(Path.GetExtension(x).ToLower()))
.Select(x => PathToList + x.Substring(localPath.Length).Replace("\\", "/"));
var currentUserName = HttpContext.Current.User.Identity.Name;
//只显示该用户自己的文件
var userFiles = allFiles.Where(file => file.Contains(currentUserName)).ToList();
buildingList.AddRange(userFiles);
Total = buildingList.Count;
FileList = buildingList.OrderBy(x => x).Skip(Start).Take(Size).ToArray();
}
catch (UnauthorizedAccessException)
{
State = ResultState.AuthorizError;
}
catch (DirectoryNotFoundException)
{
State = ResultState.PathNotFound;
}
catch (IOException)
{
State = ResultState.IOError;
}
finally
{
WriteResult();
}
}
public override void Process()
{
try
{
Start = String.IsNullOrEmpty(Request["start"]) ? 0 : Convert.ToInt32(Request["start"]);
Size = String.IsNullOrEmpty(Request["size"])
? UeditorConfig.GetInt("imageManagerListSize")
: Convert.ToInt32(Request["size"]);
}
catch (FormatException)
{
State = ResultState.InvalidParam;
WriteResult();
return;
}
var buildingList = new List <String>();
try
{
var localPath = Server.MapPath(PathToList);
buildingList.AddRange(Directory.GetFiles(localPath, "*", SearchOption.AllDirectories)
.Where(x => SearchExtensions.Contains(Path.GetExtension(x).ToLower()))
.Select(x => PathToList + x.Substring(localPath.Length).Replace("\\", "/")));
Total = buildingList.Count;
FileList = buildingList.OrderBy(x => x).Skip(Start).Take(Size).ToArray();
}
catch (UnauthorizedAccessException)
{
State = ResultState.AuthorizError;
}
catch (DirectoryNotFoundException)
{
State = ResultState.PathNotFound;
}
catch (IOException)
{
State = ResultState.IOError;
}
finally
{
WriteResult();
}
}
/// <summary>
/// Set the result of the test
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="message">A message associated with the result state</param>
/// <param name="stackTrace">Stack trace giving the location of the command</param>
public void SetResult(ResultState resultState, string message, string stackTrace)
{
#if PARALLEL
RwLock.EnterWriteLock();
#endif
try
{
ResultState = resultState;
Message = message;
StackTrace = stackTrace;
}
finally
{
#if PARALLEL
RwLock.ExitWriteLock();
#endif
}
// Set pseudo-counts for a test case
//if (IsTestCase(test))
//{
// passCount = 0;
// failCount = 0;
// skipCount = 0;
// inconclusiveCount = 0;
// switch (ResultState.Status)
// {
// case TestStatus.Passed:
// passCount++;
// break;
// case TestStatus.Failed:
// failCount++;
// break;
// case TestStatus.Skipped:
// skipCount++;
// break;
// default:
// case TestStatus.Inconclusive:
// inconclusiveCount++;
// break;
// }
//}
}
public void RestoreTestResult(TestResult result)
{
var resultState = new ResultState((TestStatus)Enum.Parse(typeof(TestStatus), status), label,
(FailureSite)Enum.Parse(typeof(FailureSite), site));
var baseType = result.GetType().BaseType;
baseType.GetField("_resultState", flags).SetValue(result, resultState);
baseType.GetField("_output", flags).SetValue(result, new StringBuilder(output));
baseType.GetField("_duration", flags).SetValue(result, duration);
if (!string.IsNullOrEmpty(message))
{
baseType.GetField("_message", flags).SetValue(result, message);
}
baseType.GetField("_stackTrace", flags).SetValue(result, stacktrace);
baseType.GetProperty("StartTime", flags)
.SetValue(result, DateTime.FromOADate(startTimeAO), null);
baseType.GetProperty("EndTime", flags)
.SetValue(result, DateTime.FromOADate(endTimeAO), null);
}
// Update is called once per frame
void Update()
{
switch (state)
{
case ResultState.BackDis:
BlackImg.transform.position += new Vector3(150f, 0f, 0f);
if (BlackImg.transform.position.x > 3000)
{
state = ResultState.TextMove;
}
_soundManager.PlaySE(SEID.Game_Character_General_Move);
break;
case ResultState.TextMove:
TextMove();
break;
//背景の透明度を変えている
case ResultState.CharaDis:
changecolor.a += 0.1f;
if (changecolor.a >= 1)
{
changecolor.a = 1f;
CharaImg.color = changecolor;
TextInstance();
WordPos.SetActive(true);
state = ResultState.TextDis;
}
else
{
CharaImg.color = changecolor;
}
break;
case ResultState.TextDis:
TextDis();
break;
case ResultState.SceneJump:
OnClick();
break;
}
}
private void UpdateStatus(ResultState result)
{
// Status can only get worse during a run, so we can avoid
// unnecessary calls to Invoke by checking current status.
var currentStatus = _progressBar.Status;
if (currentStatus != TestProgressBarStatus.Failure)
switch (result.Status)
{
case TestStatus.Failed:
_progressBar.Status = TestProgressBarStatus.Failure;
break;
case TestStatus.Skipped:
if (result.Label == "Invalid")
_progressBar.Status = TestProgressBarStatus.Failure;
else if (result.Label == "Ignored" && currentStatus != TestProgressBarStatus.Warning)
_progressBar.Status = TestProgressBarStatus.Warning;
break;
}
}
public override void Process()
{
try
{
Start = String.IsNullOrEmpty(Request["start"]) ? 0 : Convert.ToInt32(Request["start"]);
Size = String.IsNullOrEmpty(Request["size"]) ? Config.GetInt("imageManagerListSize") : Convert.ToInt32(Request["size"]);
// Size = Config.GetInt("imageManagerListSize") == 0 ? 20 : Config.GetInt("imageManagerListSize");
}
catch (FormatException)
{
State = ResultState.InvalidParam;
WriteResult();
return;
}
var buildingList = new List <String>();
try
{
// var localPath = Server.MapPath(PathToList);
buildingList.AddRange(Directory.GetFiles(PathToList, "*", SearchOption.AllDirectories)
.Where(x => SearchExtensions.Contains(Path.GetExtension(x).ToLower()) && FancyFix.Tools.Usual.Utils.IsOriginPic(x))
.Select(x => FancyFix.Tools.Usual.Utils.GetLastFolderName(PathToList) + "/" + x.Substring(PathToList.Length).Replace("\\", "/")));
FileList = buildingList.OrderByDescending(x => new FileInfo(x).FullName).Skip(Start).Take(Size).ToArray();
}
catch (UnauthorizedAccessException)
{
State = ResultState.AuthorizError;
}
catch (DirectoryNotFoundException)
{
State = ResultState.PathNotFound;
}
catch (IOException)
{
State = ResultState.IOError;
}
finally
{
WriteResult();
}
}
private ITestResult CheckResult(string methodName, ResultState expectedResultState, int expectedAsserts, params string[] assertionMessageRegex)
{
ITestResult result = TestBuilder.RunTestCase(typeof(AssertMultipleFixture), methodName);
Assert.That(result.ResultState, Is.EqualTo(expectedResultState), "ResultState");
Assert.That(result.AssertCount, Is.EqualTo(expectedAsserts), "AssertCount");
Assert.That(result.AssertionResults.Count, Is.EqualTo(assertionMessageRegex.Length), "Number of AssertionResults");
if (result.ResultState.Status == TestStatus.Failed)
{
Assert.That(result.StackTrace, Is.Not.Null.And.Contains(methodName), "StackTrace");
}
if (result.AssertionResults.Count > 0)
{
int numFailures = result.AssertionResults.Count;
if (expectedResultState == ResultState.Error)
{
--numFailures;
}
if (numFailures > 1)
{
Assert.That(result.Message, Contains.Substring("Multiple failures or warnings in test:"));
}
int i = 0;
foreach (var assertion in result.AssertionResults)
{
// Since the order of argument evaluation is not guaranteed, we don't
// want 'i' to appear more than once in the Assert statement.
string errmsg = string.Format("AssertionResult {0}", i + 1);
Assert.That(assertion.Message, Does.Match(assertionMessageRegex[i++]), errmsg);
Assert.That(result.Message, Contains.Substring(assertion.Message), errmsg);
// NOTE: This test expects the stack trace to contain the name of the method
// that actually caused the failure. To ensure it is not optimized away, we
// compile the testdata assembly with optimizations disabled.
Assert.That(assertion.StackTrace, Is.Not.Null.And.Contains(methodName), errmsg);
}
}
return(result);
}
/// <summary>
/// タップの入力待機
/// </summary>
/// <returns></returns>
IEnumerator InputWait()
{
transition = 0;// 遷移状況を初期化
while (true)
{
if (Input.GetMouseButtonDown(0))// タップされたとき
{
switch (transition)
{
case 0:
ResultSkip(); // 演出のスキップ
transition++; // 遷移状況を1つ進める
break;
case 1:
transition++; // 遷移状況を1つ進める
DeleteScoreUI(); // 生成したUIを削除
rankingCount = 0; // ランキングカウントのリセット
label[0].SetActive(false); // リザルトCanvasを非表示
label[1].SetActive(true); // ランキングCanvasを表示
state = ResultState.RANKING; // ステートを更新
StartCoroutine(RankingCoroutine()); // コルーチンの再生
//SetFlg();
break;
case 2:
ResultSkip(); // 演出のスキップ
transition++; // 遷移状況を1つ進める
break;
case 3:
sf.SceneChange("Game"); // Gameシーンへ
break;
default:
Debug.LogError("以降の処理がありません"); // 例外処理
break;
}
}
yield return(null);// 1フレーム待つ
}
}
object ToXmlString(ResultState resultState)
{
if (resultState == ResultState.Success)
{
return("Success");
}
else if (resultState == ResultState.Inconclusive)
{
return("Inconclusive");
}
else if (resultState == ResultState.Ignored)
{
return("Ignored");
}
else
{
return("Failure");
}
}
public override UEditorResult Process()
{
try
{
Start = string.IsNullOrWhiteSpace(Request.Query["start"]) ? 0 : Convert.ToInt32(Request.Query["start"]);
Size = string.IsNullOrWhiteSpace(Request.Query["size"]) ? Config.GetInt("imageManagerListSize") : Convert.ToInt32(Request.Query["size"]);
}
catch (FormatException)
{
State = ResultState.InvalidParam;
return(WriteResult());
}
UEditorResult result;
var buildingList = new List <String>();
try
{
var localPath = Path.Combine(Config.WebRootPath, Config.UploadPath, PathToList.Replace("/", "\\"));
buildingList.AddRange(Directory.GetFiles(localPath, "*", SearchOption.AllDirectories)
.Where(x => SearchExtensions.Contains(Path.GetExtension(x).ToLower()))
.Select(x => Config.UploadPath + "/" + PathToList + x.Substring(localPath.Length).Replace("\\", "/")));
Total = buildingList.Count;
FileList = buildingList.OrderBy(x => x).Skip(Start).Take(Size).ToArray();
}
catch (UnauthorizedAccessException)
{
State = ResultState.AuthorizError;
}
catch (DirectoryNotFoundException)
{
State = ResultState.PathNotFound;
}
catch (IOException)
{
State = ResultState.IOError;
}
finally
{
result = WriteResult();
}
return(result);
}
public override void Process()
{
try
{
Start = ((!string.IsNullOrEmpty(base.Request["start"])) ? Convert.ToInt32(base.Request["start"]) : 0);
Size = (string.IsNullOrEmpty(base.Request["size"]) ? UEConfig.GetInt("imageManagerListSize") : Convert.ToInt32(base.Request["size"]));
}
catch (FormatException)
{
State = ResultState.InvalidParam;
WriteResult();
return;
}
List <string> list = new List <string>();
try
{
string localPath = base.Server.MapPath(PathToList);
list.AddRange(from x in Directory.GetFiles(localPath, "*", SearchOption.AllDirectories)
where SearchExtensions.Contains(Path.GetExtension(x).ToLower())
select PathToList + x.Substring(localPath.Length).Replace("\\", "/"));
Total = list.Count;
FileList = (from x in list
orderby x
select x).Skip(Start).Take(Size).ToArray();
}
catch (UnauthorizedAccessException)
{
State = ResultState.AuthorizError;
}
catch (DirectoryNotFoundException)
{
State = ResultState.PathNotFound;
}
catch (IOException)
{
State = ResultState.IOError;
}
finally
{
WriteResult();
}
}
public void AddTestRun(int suiteId, int testCaseId, ResultState caseResult, string errorOuput, string comment)
{
if (RunData.Testrun == null)
{
throw new Exception("InitializeTestRun method has not been called, please call this at the start of the test run");
}
//Get test points
ITestPointCollection testpoints = RunData.Plan.QueryTestPoints("SELECT * FROM TestPoint WHERE SuiteId = " + suiteId + " and TestCaseId = " + testCaseId);
foreach (ITestPoint tp in testpoints)
{
RunData.Testrun.AddTestPoint(tp, null);
}
RunData.RunCacheData.Add(new RunCache()
{
CaseResult = caseResult, Comment = comment, ErrorOutput = errorOuput
});
}
/// <summary>
/// 确认所有的报警
/// </summary>
/// <param name="userName"></param>
/// <param name="describe"></param>
/// <returns></returns>
public object SetConfirmAllMeterAlarm(string userName, string describe)
{
ResultState resultState = new ResultState();
int result = context.SetConfirmAllMeterAlarm(userName, describe);
if (result > 0)
{
resultState.State = 0;
resultState.Details = "OK ：操作成功";
}
else
{
resultState.State = 1;
resultState.Details = "NG ：确认失败！！！";
}
return(resultState);
}
public void TestGetTestResultsWithAssemblyReturnsResults([Values] bool withChildTests,
[Values] bool runTests, [Values] bool withFilter)
{
ITestFilter filter = withFilter
? NUnitFilter.Where.Class(typeof(TestFixtureStubOne).FullName).And.Method("Test2").Build().Filter
: null;
ResultState expectedState = ResultState.Inconclusive;
if (withChildTests && runTests)
{
expectedState = withFilter ? ResultState.Success : ResultState.ChildFailure;
}
INUnitRunner runner = new NUnitRunner("suite-name");
Assembly assembly = typeof(TestFixtureStubOne).Assembly;
int expectedCount = 0;
if (withChildTests)
{
expectedCount = withFilter ? 1 : TestFixtureStubHelper.GeTestFixtureStub().TestCount;
Task <ITest> testTask = runner.AddTestAssemblyAsync(assembly);
testTask.Wait();
}
if (runTests)
{
runner.RunTests(null, filter);
}
else
{
expectedCount = 0;
}
ITestResult results = runner.GetTestResults(assembly);
Assert.IsNotNull(results);
Assert.AreEqual(expectedState, results.ResultState);
int totalCount = results.FailCount + results.InconclusiveCount + results.PassCount + results.SkipCount +
results.WarningCount;
Assert.AreEqual(expectedCount, totalCount);
}
public ActionResult EditPWD(UserInfo clsUserInfo)
{
UserInfo user = new UserInfo();
user = (UserInfo)Session["LoginUser"];
if (FormsAuthentication.HashPasswordForStoringInConfigFile(clsUserInfo.OldPasswrd.Trim(), "md5") != user.UserPasswrd)
{
return(JavaScript("editFormError('修改失败,旧密码不正确！');"));
}
else if (clsUserInfo.UserPasswrd.Trim() != clsUserInfo.UserRePasswrd.Trim())
{
return(JavaScript("editFormError('修改失败,新密码不一致！');"));
}
else
{
UserInfo Userobj = new UserInfo();
Userobj.UserPasswrd = FormsAuthentication.HashPasswordForStoringInConfigFile(clsUserInfo.UserPasswrd, "md5");
Userobj.UserLname = clsUserInfo.UserLname;
ResultState result = userInfoBll.ModifyUserPWD(Userobj);
new LogMessage().Save("用户：" + user.UserLname + "修改密码;");
switch (result)
{
case ResultState.SUCCEED:
//刷新用户
Transfers.ClintSendCommData(1160, "1108", "", "", "", "", "", "", "", "", "", "1", "1", "", "", "", "", "", "");
return(JavaScript("editFormSucceed();"));
case ResultState.ERROR:
return(JavaScript("editFormError('');"));
case ResultState.EXIST:
return(JavaScript("editFormExist();"));
default:
return(JavaScript("editFormSucceed();"));
}
}
}
public void TearDown()
{
if (LastOutcome == null || TestContext.CurrentContext.Result.Outcome != ResultState.Success)
{
//this class has single driver session for all test methods
//we don't want to mark a test as passed if it was already marked as failed
LastOutcome = TestContext.CurrentContext.Result.Outcome;
//LastOutcomeMessage = TestContext.CurrentContext.Result.StackTrace;
LastOutcomeMessage = TestContext.CurrentContext.Result.Message;
/*
* example stack trace:
* (Marked via REST API: at OpenQA.Selenium.Support.UI.DefaultWait`1.ThrowTimeoutException(String exceptionMessage, Exception lastException) at OpenQA.Selenium.Support.UI.DefaultWait`1.Until[TResult](Func`2 condition) at BrowserSupport.Tests.Test.BaseTest.WaitForText(IWeb)
*
* example message:
* (Marked via REST API: OpenQA.Selenium.WebDriverTimeoutException : Timed out after 5 seconds)
*/
}
}
public int CalcImageIndex(ResultState outcome)
{
switch (outcome.Status)
{
case TestStatus.Inconclusive:
return(InconclusiveIndex);
case TestStatus.Passed:
return(SuccessIndex);
case TestStatus.Failed:
return(FailureIndex);
case TestStatus.Skipped:
default:
return(outcome.Label == "Ignored"
? IgnoredIndex
: SkippedIndex);
}
}
public void TreeShowsProperResult(ResultState resultState, int expectedIndex)
{
_model.IsPackageLoaded.Returns(true);
_model.HasTests.Returns(true);
var result = resultState.Status.ToString();
var label = resultState.Label;
var testNode = new TestNode("<test-run id='1'><test-suite id='123'/></test-run>");
var resultNode = new ResultNode(string.IsNullOrEmpty(label)
? string.Format("<test-suite id='123' result='{0}'/>", result)
: string.Format("<test-suite id='123' result='{0}' label='{1}'/>", result, label));
_model.Tests.Returns(testNode);
_model.Events.TestLoaded += Raise.Event <TestNodeEventHandler>(new TestNodeEventArgs(testNode));
_model.Events.SuiteFinished += Raise.Event <TestResultEventHandler>(new TestResultEventArgs(resultNode));
_view.Tree.Received().SetImageIndex(Arg.Compat.Any <TreeNode>(), expectedIndex);
}
public override void Process()
{
try
{
var filePath = this.Request["path"].ToString();
var fileRecordService = EngineContext.Current.Resolve <IFileRecordService>();
fileRWhelper.DeleteFile(filePath);
fileRecordService.DeleteFileRecordByPath(filePath);
}
catch (Exception ex)
{
State = ResultState.Error;
WriteResult();
return;
}
finally
{
WriteResult();
}
}
private static string GetResultStatus(ResultState resultState)
{
string status = resultState.Label;
if (string.IsNullOrEmpty(status))
{
status = resultState.Status.ToString();
}
if (status == "Failed" || status == "Error")
{
var site = resultState.Site.ToString();
if (site == "SetUp" || site == "TearDown")
{
status = site + " " + status;
}
}
return(status);
}
public ExpectedResultCommand(TestCommand command, ResultState expectedResult, params string[] messageFragments)
: base(command)
{
AfterTest = (context) =>
{
var result = context.CurrentResult;
if (result.ResultState != expectedResult)
{
result.SetResult(ResultState.Failure,
$"Expected {expectedResult} result but was {result.ResultState}.");
return;
}
if (messageFragments.Length > 0)
{
var message = result.Message;
if (string.IsNullOrEmpty(message))
{
result.SetResult(ResultState.Failure,
"Result message was null or empty");
return;
}
else
{
foreach (string fragment in messageFragments)
{
if (!result.Message.Contains(fragment))
{
result.SetResult(ResultState.Failure,
$"Result message did not match\nExpected substring: {fragment}\nBut was: {result.Message}");
return;
}
}
}
}
result.SetResult(ResultState.Success);
result.AssertionResults.Clear();
};
}
private void RunTearDownMethods(TestExecutionContext context)
{
try
{
if (tearDownMethods != null)
{
int index = tearDownMethods.Length;
while (--index >= 0)
{
Reflect.InvokeMethod(tearDownMethods[index], tearDownMethods[index].IsStatic ? null : context.TestObject);
}
}
}
catch (Exception ex)
{
if (ex is NUnitException)
{
ex = ex.InnerException;
}
// TODO: What about ignore exceptions in teardown?
ResultState resultState = context.CurrentResult.ResultState == ResultState.Cancelled
? ResultState.Cancelled
: ResultState.Error;
// TODO: Can we move this logic into TestResult itself?
string message = "TearDown : " + ExceptionHelper.BuildMessage(ex);
if (context.CurrentResult.Message != null)
{
message = context.CurrentResult.Message + NUnit.Env.NewLine + message;
}
string stackTrace = "--TearDown" + NUnit.Env.NewLine + ExceptionHelper.BuildStackTrace(ex);
if (context.CurrentResult.StackTrace != null)
{
stackTrace = context.CurrentResult.StackTrace + NUnit.Env.NewLine + stackTrace;
}
context.CurrentResult.SetResult(resultState, message, stackTrace);
}
}
public static void MarkTestStatusOnBrowserStack(RemoteWebDriver driver, ResultState outcome, string message)
{
if (IsCloud == false)
{
throw new Exception("You are not testing on the cloud");
}
string status = "failed";
if (outcome.Equals(ResultState.Success))
{
status = "passed";
}
JObject json = new JObject();
json["status"] = status;
json["reason"] = message;
string reqString = json.ToString();
SessionId sessionId = driver.SessionId;
byte[] requestData = Encoding.UTF8.GetBytes(reqString);
Uri myUri = new Uri($"https://www.browserstack.com/automate/sessions/{sessionId.ToString()}.json");
WebRequest myWebRequest = HttpWebRequest.Create(myUri);
HttpWebRequest myHttpWebRequest = (HttpWebRequest)myWebRequest;
myWebRequest.ContentType = "application/json";
myWebRequest.Method = "PUT";
myWebRequest.ContentLength = requestData.Length;
using (Stream st = myWebRequest.GetRequestStream()) st.Write(requestData, 0, requestData.Length);
NetworkCredential myNetworkCredential = new NetworkCredential(Config.BrowserstackUsername, Config.BrowserstackAccessKey);
CredentialCache myCredentialCache = new CredentialCache();
myCredentialCache.Add(myUri, "Basic", myNetworkCredential);
myHttpWebRequest.PreAuthenticate = true;
myHttpWebRequest.Credentials = myCredentialCache;
myWebRequest.GetResponse().Close();
}
public JsonResult Login(Student student)
{
ResultState resultState = new ResultState();
if (!StudentNameExits(student.Name))
{
resultState.Message = "该用户不存在";
return(new JsonResult(resultState));
}
var stuInDb = _context.students.Where(x =>
x.StudentID == student.StudentID)
.FirstOrDefault();
if (student.Name != stuInDb.Name)
{
resultState.Message = "用户名错误";
return(new JsonResult(resultState));
}
if (student.Password == stuInDb.Password)
{
resultState.Success = true;
if (stuInDb.isAdmin == 1)
{
resultState.Code = 2;//Code=2表示学生管理员
resultState.Message = "学生管理员登录成功";
}
else
{
resultState.Code = 1;//Code=1表示非学生管理员登陆成功
resultState.Message = "学生登录成功";
}
resultState.value = stuInDb;
_helper.SetCookie("token",
stuInDb.StudentID + "," +
stuInDb.Name + "," +
stuInDb.Enrollment + "," +
stuInDb.Department + "," +
stuInDb.isAdmin);
}
return(new JsonResult(resultState));
}
public override void Process()
{
try
{
Start = String.IsNullOrEmpty(Request["start"]) ? 0 : Convert.ToInt32(Request["start"]);
Size = String.IsNullOrEmpty(Request["size"])
? Config.GetInt("imageManagerListSize")
: Convert.ToInt32(Request["size"]);
}
catch (FormatException)
{
State = ResultState.InvalidParam;
WriteResult();
return;
}
var buildingList = new List <String>();
try
{
buildingList.AddRange(_uploadFolder.ListFiles(PathToList, SearchExtensions, Start, Size, true)
.Select(x => _uploadFolder.GetUrl(x)));
Total = buildingList.Count;
FileList = buildingList.OrderBy(x => x).Skip(Start).Take(Size).ToArray();
}
catch (UnauthorizedAccessException)
{
State = ResultState.AuthorizError;
}
catch (DirectoryNotFoundException)
{
State = ResultState.PathNotFound;
}
catch (IOException)
{
State = ResultState.IOError;
}
finally
{
WriteResult();
}
}
private void ResultButton_Click(object sender, EventArgs e)
{
switch (this.ResultStatus)
{
case ResultState.None:
this.ResultStatus = ResultState.Done;
break;
case ResultState.Done:
this.ResultStatus = ResultState.Cancel;
break;
default:
this.ResultStatus = ResultState.None;
break;
}
var args = new ResultChangedEventArgs(long.Parse(this.Tag.ToString()), (short)this.ResultStatus);
this.OnResultChanged?.Invoke(this, args);
}
public void MappingTest(string commandLineArguments, ResultState expectedResult, string firstArgumentValue, ParserNotation notation)
{
// Setup
var parser = new CommandParser(notation);
var args = parser.Parse(commandLineArguments);
var configuration = new CommandConfiguration();
configuration.CommandAssemblies.Add(Assembly.GetExecutingAssembly());
var lookup = new CommandLookup(configuration);
var command = lookup.GetCommand(args.First().Key);
Assert.NotNull(args);
Assert.NotNull(command);
// Test
var target = new CommandMapper();
var result = target.Map(args.Skip(1), command.Arguments);
// Assert
Assert.NotNull(result);
Assert.True(result.State == expectedResult);
Assert.True(firstArgumentValue == null || firstArgumentValue == result?.ResultArguments?.First().ToString());
}
// Public for testing
public static TestOutcome ResultStateToTestOutcome(ResultState resultState)
{
switch (resultState)
{
case ResultState.Cancelled:
return TestOutcome.None;
case ResultState.Error:
return TestOutcome.Failed;
case ResultState.Failure:
return TestOutcome.Failed;
case ResultState.Ignored:
return TestOutcome.Skipped;
case ResultState.Inconclusive:
return TestOutcome.None;
case ResultState.NotRunnable:
return TestOutcome.Failed;
case ResultState.Skipped:
return TestOutcome.Skipped;
case ResultState.Success:
return TestOutcome.Passed;
}
return TestOutcome.None;
}
public Result(ResultState state)
{
State = state;
}
private void RunTestAndVerifyResult(ResultState expected)
{
result = test.Run();
VerifyResult(expected);
}
/// <summary>
/// Set the result of the test.
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="ex">The exception that caused this result</param>
public void SetResult(ResultState resultState, Exception ex, FailureSite failureSite)
{
if (resultState == ResultState.Cancelled)
SetResult(resultState, "Test cancelled by user", BuildStackTrace(ex));
else if (resultState == ResultState.Error)
SetResult( resultState, BuildMessage(ex), BuildStackTrace(ex), failureSite);
else
SetResult(resultState, ex.Message, ex.StackTrace, failureSite);
}
/// <summary>
/// Set the result of the test
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="reason">The reason the test was not run</param>
/// <param name="stackTrace">Stack trace giving the location of the command</param>
public void SetResult(ResultState resultState, string reason, string stackTrace)
{
SetResult(resultState, reason, stackTrace, FailureSite.Test);
}
public void NotRun(string message)
{
this.resultState = ResultState.NotRun;
this.message = message;
}
// Returns ResultState translated to a v3 string representation
private static string GetTranslatedResultState(ResultState resultState)
{
switch (resultState)
{
case ResultState.Inconclusive:
return "Inconclusive";
case ResultState.NotRunnable:
return "Failed:Invalid";
case ResultState.Skipped:
return "Skipped";
case ResultState.Ignored:
return "Skipped:Ignored";
case ResultState.Success:
return "Passed";
case ResultState.Failure:
return "Failed";
case ResultState.Error:
return "Failed:Error";
case ResultState.Cancelled:
return "Failed:Cancelled";
}
return resultState.ToString();
}
public void Success()
{
this.resultState = ResultState.Success;
this.message = null;
}
public void TestFinished_OutcomesAreCorrectlyTranslated(ResultState resultState, TestOutcome outcome, string message)
{
fakeNUnitResult.SetResult(resultState, message, null);
listener.TestFinished(fakeNUnitResult);
Assume.That(testLog.Events.Count, Is.EqualTo(2));
Assume.That(
testLog.Events[0].EventType,
Is.EqualTo(FakeFrameworkHandle.EventType.RecordEnd));
Assume.That(
testLog.Events[1].EventType,
Is.EqualTo(FakeFrameworkHandle.EventType.RecordResult));
Assert.AreEqual(outcome, testLog.Events[0].TestOutcome);
Assert.AreEqual(outcome, testLog.Events[1].TestResult.Outcome);
Assert.AreEqual(message, testLog.Events[1].TestResult.ErrorMessage);
}
public Result(ResultState state)
{
this.state = state;
}
public void Error(string message)
{
this.resultState = ResultState.Error;
if (this.message == null || this.message == string.Empty)
this.message = message;
else
this.message = this.message + NUnitLite.Env.NewLine + message;
}
private void MarkTestNotRun(
Test test, ResultState resultState, string ignoreReason, TestResult suiteResult, EventListener listener, ITestFilter filter)
{
if (test is TestSuite)
{
listener.SuiteStarted(test.TestName);
TestResult result = new TestResult( new TestInfo(test) );
result.SetResult( resultState, ignoreReason, null );
MarkTestsNotRun(test.Tests, resultState, ignoreReason, result, listener, filter);
suiteResult.AddResult(result);
listener.SuiteFinished(result);
}
else
{
listener.TestStarted(test.TestName);
TestResult result = new TestResult( new TestInfo(test) );
result.SetResult( resultState, ignoreReason, null );
suiteResult.AddResult(result);
listener.TestFinished(result);
}
}
public Result(ResultState state, Coordinate coordinate)
: this(state)
{
Coordinate = coordinate;
}
private void VerifyResult(ResultState expected)
{
Assert.That( result.ResultState, Is.EqualTo( expected ) );
}
public Result(ResultState state, Coordinate coordinate, Dictionary<Entry, double> entriesDistances)
: this(state, coordinate)
{
EntriesDistances = entriesDistances;
}
/// <summary>
/// Set the result of the test
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="reason">The reason the test was not run</param>
/// <param name="stackTrace">Stack trace giving the location of the command</param>
/// <param name="failureSite">The location of the failure, if any</param>
public void SetResult(ResultState resultState, string reason, string stack, FailureSite failureSite)
{
if (failureSite == FailureSite.SetUp)
reason = "SetUp : " + reason;
else if (failureSite == FailureSite.TearDown)
{
reason = "TearDown : " + reason;
stack = "--TearDown" + Environment.NewLine + stack;
if (this.message != null)
reason = this.message + Environment.NewLine + reason;
if (this.stackTrace != null)
stack = this.stackTrace + Environment.NewLine + stack;
}
this.resultState = resultState;
this.message = reason;
this.stackTrace = stack;
this.failureSite = failureSite;
}
public TestOutcome ResultStateToTestOutcome(ResultState resultState)
{
return TestConverter.ResultStateToTestOutcome(resultState);
}
public void Error(Exception ex)
{
this.resultState = ResultState.Error;
this.message = ex.GetType().ToString() + " : " + ex.Message;
#if !NETCF_1_0
this.stackTrace = ex.StackTrace;
#endif
}
