public void ToString_WhenSuccess_DoesNotContainError()
{
var r = TryResult.Succeed();
var s = r.ToString();
Assert.IsFalse(s.Contains("error", StringComparison.InvariantCultureIgnoreCase));
}
public void Succeed_SetsResult()
{
var result = 1;
var r = TryResult <int> .Succeed(result);
Assert.AreEqual(result, r.Result);
}
public async Task ThenTryAsync_WhenTryFailed_ReturnsOriginalError()
{
var t = TryResult.Fail("err");
var t2 = await t.ThenTryAsync(async() => TryResult.Succeed());
Assert.AreEqual(t, t2);
}
public void ThenTry_WhenTryFailed_ReturnsOriginalError()
{
TryResult t = "err";
var t2 = t.ThenTry(() => TryResult.Succeed());
Assert.AreEqual(t, t2);
}
public void ThenTryTIn_WhenTrySucceededAndExecutorSucceeds_ReturnsResultOfOriginalTry()
{
TryResult <int> t = 1;
var tr = t.ThenTry(r => TryResult.Succeed());
Assert.AreEqual(t, tr);
}
public async Task AsyncThenTryAsyncIn_WhenTryFailed_ReturnsOriginalError()
{
TryResult <int> tr = "err";
var t = Task.FromResult(tr);
var t2 = await t.ThenTryAsync(async r => TryResult.Succeed());
Assert.AreEqual(tr, t2);
}
public void ThenTOut_WhenTrySucceeded_ReturnsResultOfExecutor()
{
var t = TryResult.Succeed();
var result = "yay";
var tr = t.Then(() => result);
Assert.AreEqual(result, tr.Result);
}
public void CastToTuple_WhenSuccess_SetsSuccessAndError()
{
var r = TryResult.Succeed();
(bool, string)o = r;
Assert.AreEqual(r.Success, o.Item1);
Assert.AreEqual(r.ErrorMessage, o.Item2);
}
public async Task ThenAsyncTOut_WhenTrySucceeded_ReturnsResultOfExecutor()
{
var t = TryResult.Succeed();
var result = 1;
var tr = await t.ThenAsync(async() => result);
Assert.AreEqual(result, tr.Result);
}
public async Task AsyncThenTry_WhenTryFailed_ReturnsOriginalError()
{
var r = TryResult.Fail("err");
var t = Task.FromResult(r);
var t2 = await t.ThenTryAsync(() => TryResult.Succeed());
Assert.AreEqual(r, t2);
}
public void Deconstruct_WhenSuccess_Deconstructs()
{
var r = TryResult.Succeed();
var(success, errMsg) = r;
Assert.AreEqual(r.Success, success);
Assert.AreEqual(r.ErrorMessage, errMsg);
}
public void ThenTryTOut_WhenTrySucceededAndExecutorSucceeds_ReturnsResultOfExecutor()
{
var t = TryResult.Succeed();
var result = 1;
var tr = t.ThenTry <int>(() => result);
Assert.AreEqual(result, tr.Result);
}
public void ThenTryTOut_WhenTrySucceededAndExecutorFails_ReturnsExecutorError()
{
var t = TryResult.Succeed();
var err = "err";
var tr = t.ThenTry <int>(() => err);
Assert.AreEqual(err, tr.ErrorMessage);
}
public void ThenTry_WhenTrySucceeded_ReturnsResultOfExecutor()
{
var t = TryResult.Succeed();
var err = "err";
t = t.ThenTry(() => TryResult.Fail(err));
Assert.AreEqual(err, t.ErrorMessage);
}
public void DeconstructWithResult_WhenSuccess_Deconstructs()
{
var r = TryResult <int> .Succeed(1);
var(success, result, errMsg) = r;
Assert.AreEqual(r.Success, success);
Assert.AreEqual(r.Result, result);
Assert.AreEqual(r.ErrorMessage, errMsg);
}
public async Task ThenAsync_WhenTrySucceeded_Executes()
{
TryResult t = TryResult.Succeed();
var executed = false;
await t.ThenAsync(async() =>
{
executed = true;
});
Assert.IsTrue(executed);
}
public async Task ThenTryAsync_WhenTryFailed_DoesNotExecute()
{
TryResult t = "err";
var executed = false;
await t.ThenTryAsync(async() =>
{
executed = true;
return(TryResult.Succeed());
});
Assert.IsFalse(executed);
}
public async Task ThenTryAsyncTOut_WhenTrySucceeded_Executes()
{
var t = TryResult.Succeed();
var executed = false;
await t.ThenTryAsync <int>(async() =>
{
executed = true;
return(1);
});
Assert.IsTrue(executed);
}
public void Then_WhenTrySucceeded_Executes()
{
var t = TryResult.Succeed();
var executed = false;
t.Then(() =>
{
executed = true;
});
Assert.IsTrue(executed);
}
public async Task AsyncThenTryAsyncIn_WhenTryFailed_DoesNotExecute()
{
var t = FailedTask <int>("err");
var executed = false;
await t.ThenTryAsync(async r =>
{
executed = true;
return(TryResult.Succeed());
});
Assert.IsFalse(executed);
}
public async Task AsyncThenTryAsyncIn_WhenTrySucceeded_Executes()
{
var t = SucceedTask(1);
var executed = false;
await t.ThenTryAsync(async r =>
{
executed = true;
return(TryResult.Succeed());
});
Assert.IsTrue(executed);
}
public void ThenTry_WhenTryFailed_DoesNotExecute()
{
TryResult t = "err";
var executed = false;
t.ThenTry(() =>
{
executed = true;
return(TryResult.Succeed());
});
Assert.IsFalse(executed);
}
public void ThenTryTOut_WhenTrySucceeded_Executes()
{
var t = TryResult.Succeed();
var executed = false;
t.ThenTry <int>(() =>
{
executed = true;
return(1);
});
Assert.IsTrue(executed);
}
public void ThenTryTIn_WhenTrySucceeded_Executes()
{
TryResult <int> t = 1;
var executed = false;
t.ThenTry(() =>
{
executed = true;
return(TryResult.Succeed());
});
Assert.IsTrue(executed);
}
public void Succeed_SetsSuccessToTrue()
{
var r = TryResult.Succeed();
Assert.IsTrue(r.Success);
}
public void Succeed_SetsErrorMessageToNull()
{
var r = TryResult.Succeed();
Assert.IsNull(r.ErrorMessage);
}
private void GetPlaceFromPicker(Intent data)
{
// taskCompletionSource = new TaskCompletionSource<TryResult<Place>>(); //ошибка, если нет строки;
var placePicked = PlacePicker.GetPlace(this, data);
var place = new Place(placePicked?.NameFormatted?.ToString(), placePicked.LatLng.Latitude, placePicked.LatLng.Longitude);
((MainActivity)CrossCurrentActivity.Current.Activity).TaskCompletionSource.TrySetResult(TryResult <Place> .Succeed(place));
}
public static Task <TryResult <T> > SucceedTask <T>(T item)
{
return(Task.FromResult(TryResult <T> .Succeed(item)));
}
public static Task <TryResult> SucceedTask()
{
return(Task.FromResult(TryResult.Succeed()));
}
public void AsyncThenTryAsyncIn_WhenTryResultResultIsNull_ThrowsInvalidOperationException()
{
var t = NullTask <int>();
Assert.ThrowsAsync <InvalidOperationException>(() => t.ThenTryAsync(async r => TryResult.Succeed()));
}
