public void GenerateValidationMessage_WithNullExpression_Throws()
{
// Arrange
var metadataProvider = new TestModelMetadataProvider();
var htmlGenerator = GetGenerator(metadataProvider);
var viewContext = GetViewContext <Model>(model: null, metadataProvider: metadataProvider);
var modelExplorer = metadataProvider.GetModelExplorerForType(typeof(string), model: null);
var expected = "The name of an HTML field cannot be null or empty. Instead use methods " +
"Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper.Editor or Microsoft.AspNetCore.Mvc.Rendering." +
"IHtmlHelper`1.EditorFor with a non-empty htmlFieldName argument value.";
// Act and Assert
ExceptionAssert.ThrowsArgument(
() => htmlGenerator.GenerateValidationMessage(
viewContext,
modelExplorer: null,
expression: null,
message: "Message",
tag: "tag",
htmlAttributes: null),
"expression",
expected);
}
public void Rejection_DefendPromisesOnceMade()
{
var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy));
var addBatch = new CompositionBatch();
var removeBatch = new CompositionBatch();
var addedPart = addBatch.AddPart(new NoImportPart());
removeBatch.RemovePart(addedPart);
// Add then remove should be fine as long as exports aren't used yet.
container.Compose(addBatch);
container.Compose(removeBatch);
// Add the dependencies
container.Compose(addBatch);
// Retrieve needy which uses an export from addedPart
var export = container.GetExportedValue <Needy>();
// Should not be able to remove the addedPart because someone depends on it.
ExceptionAssert.Throws <ChangeRejectedException>(() =>
container.Compose(removeBatch));
}
public async Task AsyncClientStreamingCall_DeadlineBeforeWrite_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var tcs = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
await tcs.Task.DefaultTimeout();
return ResponseUtils.CreateResponse(HttpStatusCode.OK);
});
var systemClock = new TestSystemClock(DateTime.UtcNow);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: systemClock);
// Act
var call = invoker.AsyncClientStreamingCall<HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: systemClock.UtcNow.AddMilliseconds(10)));
// Ensure the deadline has passed
systemClock.UtcNow = systemClock.UtcNow.AddMilliseconds(200);
await Task.Delay(200);
// Assert
var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode);
Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode);
}
public void EscapedPathInExceptionMessage()
{
string json = @"{
""frameworks"": {
""dnxcore50"": {
""dependencies"": {
""System.Xml.ReaderWriter"": {
""source"": !!! !!!
}
}
}
}
}";
ExceptionAssert.Throws <JsonReaderException>(
() =>
{
JsonTextReader reader = new JsonTextReader(new StringReader(json));
while (reader.Read())
{
}
},
"Unexpected character encountered while parsing value: !. Path 'frameworks.dnxcore50.dependencies['System.Xml.ReaderWriter'].source', line 6, position 20.");
}
public async Task PickAsync_WaitForReadyWithDrop_ThrowsError()
{
// Arrange
var services = new ServiceCollection();
services.AddNUnitLogger();
var serviceProvider = services.BuildServiceProvider();
var loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>();
var resolver = new TestResolver(loggerFactory);
resolver.UpdateAddresses(new List <BalancerAddress>
{
new BalancerAddress("localhost", 80)
});
var transportFactory = new TestSubchannelTransportFactory();
var clientChannel = CreateConnectionManager(loggerFactory, resolver, transportFactory);
clientChannel.ConfigureBalancer(c => new DropLoadBalancer(c));
// Act
_ = clientChannel.ConnectAsync(waitForReady: true, CancellationToken.None).ConfigureAwait(false);
var pickTask = clientChannel.PickAsync(
new PickContext {
Request = new HttpRequestMessage()
},
waitForReady: true,
CancellationToken.None).AsTask();
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => pickTask).DefaultTimeout();
Assert.AreEqual(StatusCode.DataLoss, ex.StatusCode);
}
public void RedirectToRoute_Execute_ThrowsOnNullUrl()
{
// Arrange
var httpContext = new Mock <HttpContext>();
httpContext.Setup(o => o.Response).Returns(new Mock <HttpResponse>().Object);
var actionContext = new ActionContext(httpContext.Object,
new RouteData(),
new ActionDescriptor());
var urlHelper = GetMockUrlHelper(returnValue: null);
var result = new RedirectToRouteResult(null, new Dictionary <string, object>())
{
UrlHelper = urlHelper,
};
// Act & Assert
ExceptionAssert.ThrowsAsync <InvalidOperationException>(
async() =>
{
await result.ExecuteResultAsync(actionContext);
},
"No route matches the supplied values.");
}
public void DeserializeArraysWithPreserveObjectReferences()
{
string json = @"{
""$id"": ""1"",
""$values"": [
null,
{
""$id"": ""2"",
""$values"": [
null
]
},
{
""$id"": ""3"",
""$values"": [
{
""$id"": ""4"",
""$values"": [
{
""$ref"": ""1""
}
]
}
]
}
]
}";
ExceptionAssert.Throws <JsonSerializationException>(() =>
{
JsonConvert.DeserializeObject <string[][]>(json,
new JsonSerializerSettings {
PreserveReferencesHandling = PreserveReferencesHandling.All
});
}, @"Cannot preserve reference to array or readonly list, or list created from a non-default constructor: System.String[][]. Path '$values', line 3, position 14.");
}
public async Task NullPrimitiveValueSerializeAsODataThrows(Type valueType, object value, string mediaType, string unused)
{
// Arrange
Assert.NotNull(valueType);
Assert.NotNull(unused);
ODataConventionModelBuilder modelBuilder = ODataConventionModelBuilderFactory.Create();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
IEdmProperty property = model.EntityContainer.EntitySets().Single().EntityType().Properties().First();
ODataPath path = new ODataPath(new PropertySegment(property as IEdmStructuralProperty));
var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData");
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/WorkItems(10)/ID", configuration, "OData", path);
var formatter = FormatterTestHelper.GetFormatter(new ODataPayloadKind[] { ODataPayloadKind.Property }, request, mediaType);
// Act & Assert
Type type = (value != null) ? value.GetType() : typeof(Nullable <int>);
var content = FormatterTestHelper.GetContent(value, type, formatter, mediaType.ToString());
await ExceptionAssert.ThrowsAsync <ODataException>(
() => FormatterTestHelper.GetContentResult(content, request),
"Cannot write the value 'null' in top level property; return 204 instead.");
}
public void SerializeWrappingErrorsAndErrorHandling()
{
var serialiser = JsonSerializer.Create(new JsonSerializerSettings()
{
});
Something s = new Something
{
RootSomethingElse = new RootSomethingElse
{
SomethingElse = new SomethingElse()
}
};
RootThing r = new RootThing
{
Something = s
};
var writer = new System.IO.StringWriter();
ExceptionAssert.Throws <Exception>(
"An error occurred.",
() => { serialiser.Serialize(writer, r); });
}
public void CreateSetWithBadObjectTarget()
{
ExceptionAssert.Throws <InvalidCastException>(
() =>
{
Person p = new Person();
Movie m = new Movie();
Action <object, object> setter = ExpressionReflectionDelegateFactory.Instance.CreateSet <object>(TestReflectionUtils.GetProperty(typeof(Movie), "Name"));
setter(m, "Hi");
Assert.AreEqual(m.Name, "Hi");
setter(p, "Hi");
Assert.AreEqual(p.Name, "Hi");
},
new[]
{
"Unable to cast object of type 'Newtonsoft.Json.Tests.TestObjects.Person' to type 'Newtonsoft.Json.Tests.TestObjects.Movie'.",
"Cannot cast from source type to destination type." // mono
});
}
public void DeserializeISerializable()
{
InMemoryTraceWriter traceWriter = new InMemoryTraceWriter
{
LevelFilter = TraceLevel.Verbose
};
ExceptionAssert.Throws <SerializationException>(
"Member 'ClassName' was not found.",
() =>
{
JsonConvert.DeserializeObject <Exception>(
"{}",
new JsonSerializerSettings
{
TraceWriter = traceWriter
});
});
Assert.AreEqual("Deserializing System.Exception using ISerializable constructor. Path '', line 1, position 2.", traceWriter.TraceRecords[0].Message);
Assert.AreEqual(TraceLevel.Info, traceWriter.TraceRecords[0].Level);
Assert.AreEqual("Error deserializing System.Exception. Member 'ClassName' was not found. Path '', line 1, position 2.", traceWriter.TraceRecords[1].Message);
Assert.AreEqual(TraceLevel.Error, traceWriter.TraceRecords[1].Level);
}
public async Task AsyncClientStreamingCall_WriteAfterResult_Error()
{
// Arrange
var requestContent = new MemoryStream();
var callCount = 0;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
Interlocked.Increment(ref callCount);
_ = request.Content !.ReadAsStreamAsync();
var reply = new HelloReply {
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig();
var invoker = HttpClientCallInvokerFactory.Create(httpClient, serviceConfig: serviceConfig);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.GetServiceMethod(MethodType.ClientStreaming), string.Empty, new CallOptions());
// Assert
var responseMessage = await call.ResponseAsync.DefaultTimeout();
Assert.AreEqual("Hello world", responseMessage.Message);
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest {
Name = "1"
})).DefaultTimeout();
Assert.AreEqual(StatusCode.OK, ex.StatusCode);
}
public async Task AsyncUnaryCall_PushbackExplicitDelayExceedAttempts_Failure()
{
// Arrange
var callCount = 0;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
callCount++;
await request.Content !.CopyToAsync(new MemoryStream());
return(ResponseUtils.CreateHeadersOnlyResponse(HttpStatusCode.OK, StatusCode.Unavailable, retryPushbackHeader: "0"));
});
var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig(maxAttempts: 5);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, serviceConfig: serviceConfig);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest {
Name = "World"
});
// Assert
Assert.AreEqual(5, callCount);
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(StatusCode.Unavailable, ex.StatusCode);
}
public void InstallCommandWorksIfExcludedVersionsAndPackageIsNotFoundInRemoteRepository()
{
// Arrange
var fileSystem = new MockFileSystem();
var packages = new List <IPackage> {
PackageUtility.CreatePackage("A", "0.5")
};
var repository = new Mock <IPackageRepository>();
repository.Setup(c => c.GetPackages()).Returns(packages.AsQueryable());
repository.Setup(c => c.AddPackage(It.IsAny <IPackage>())).Throws(new Exception("Method should not be called"));
repository.Setup(c => c.RemovePackage(It.IsAny <IPackage>())).Throws(new Exception("Method should not be called"));
var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object);
var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager);
installCommand.ExcludeVersion = true;
installCommand.Arguments.Add("A");
// Act and Assert
ExceptionAssert.Throws <InvalidOperationException>(() => installCommand.ExecuteCommand(), "Unable to find package 'A'.");
// Ensure packages were not removed.
Assert.Equal(1, packages.Count);
}
public void ReadBytesFailure()
{
ExceptionAssert.Throws <JsonReaderException>(
"Error reading bytes. Unexpected token: Integer. Path 'Test1'.",
() =>
{
JObject o =
new JObject(
new JProperty("Test1", 1)
);
using (JTokenReader jsonReader = new JTokenReader(o))
{
jsonReader.Read();
Assert.AreEqual(JsonToken.StartObject, jsonReader.TokenType);
jsonReader.Read();
Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);
Assert.AreEqual("Test1", jsonReader.Value);
jsonReader.ReadAsBytes();
}
});
}
public async Task SubscribedWebHooksShouldFailOnErrors()
{
string testName = "SubscribedWebHooksShouldFailOnErrors";
string hook = "hookCalled/1";
using (new LatencyLogger(testName))
{
await ApplicationManager.RunAsync("HookSite" + testName, async hookAppManager =>
{
string customHookEventType = "CustomEvent";
string hookAddress = hookAppManager.SiteUrl + hook;
await hookAppManager.WebHooksManager.SubscribeAsync(new WebHook(customHookEventType, hookAddress));
var thrownException = await ExceptionAssert.ThrowsAsync <HttpUnsuccessfulRequestException>(async() =>
{
await hookAppManager.WebHooksManager.SubscribeAsync(new WebHook(customHookEventType + "_DifferentEvent", hookAddress));
});
Assert.Contains("Conflict", thrownException.Message);
});
}
}
public void CheckIllegalTagInput()
{
var container = MakeContainer();
ExceptionAssert.Throws <ArgumentNullException>(() =>
{
container.Tag("TestTag");
});
ExceptionAssert.Throws <ArgumentNullException>(() =>
{
container.Tag("TestTag", null);
});
ExceptionAssert.Throws <ArgumentNullException>(() =>
{
container.Tag(null, "service1", "service2");
});
ExceptionAssert.Throws <ArgumentNullException>(() =>
{
container.Tag(string.Empty, "service1", "service2");
});
}
public void DataContractSerializerDuplicateNameEnumTest()
{
MemoryStream ms = new MemoryStream();
var s = new DataContractSerializer(typeof(DuplicateEnumNameTestClass));
ExceptionAssert.Throws <InvalidDataContractException>(() =>
{
s.WriteObject(ms, new DuplicateEnumNameTestClass
{
Value = DuplicateNameEnum.foo_bar,
Value2 = DuplicateNameEnum2.foo_bar_NOT_USED
});
string xml = @"<DuplicateEnumNameTestClass xmlns=""http://schemas.datacontract.org/2004/07/Newtonsoft.Json.Tests.Converters"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">
<Value>foo_bar</Value>
<Value2>foo_bar</Value2>
</DuplicateEnumNameTestClass>";
var o = (DuplicateEnumNameTestClass)s.ReadObject(new MemoryStream(Encoding.UTF8.GetBytes(xml)));
Assert.AreEqual(DuplicateNameEnum.foo_bar, o.Value);
Assert.AreEqual(DuplicateNameEnum2.FooBar, o.Value2);
}, "Type 'Newtonsoft.Json.Tests.Converters.DuplicateNameEnum' contains two members 'foo_bar' 'and 'FooBar' with the same name 'foo_bar'. Multiple members with the same name in one type are not supported. Consider changing one of the member names using EnumMemberAttribute attribute.");
}
public void Validate_NoException_ForParameterAlias()
{
// Arrange
IEdmModel model = GetEdmModel();
IEdmEntityType edmType = model.SchemaElements.OfType <IEdmEntityType>().Single(t => t.Name == "LimitedEntity");
IEdmEntitySet entitySet = model.FindDeclaredEntitySet("Microsoft.AspNet.OData.Query.Validators.LimitedEntities");
ODataQueryContext context = new ODataQueryContext(model, edmType);
OrderByQueryOption option = new OrderByQueryOption(
"@p,@q desc",
context,
new ODataQueryOptionParser(
model,
edmType,
entitySet,
new Dictionary <string, string> {
{ "$orderby", "@p,@q desc" }, { "@p", "Id" }, { "@q", "RelatedEntity/Id" }
}));
ODataValidationSettings settings = new ODataValidationSettings();
// Act & Assert
ExceptionAssert.DoesNotThrow(() => _validator.Validate(option, settings));
}
public async Task ReadSingleMessageAsync_ExceedReceiveSize_ReturnData()
{
// Arrange
var context = HttpContextServerCallContextHelper.CreateServerCallContext(maxReceiveMessageSize: 1);
var ms = new MemoryStream(new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x02, // length = 1
0x10,
0x10
});
var pipeReader = PipeReader.Create(ms);
// Act
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => pipeReader.ReadSingleMessageAsync(context, TestDataMarshaller.ContextualDeserializer).AsTask()).DefaultTimeout();
// Assert
Assert.AreEqual("Received message exceeds the maximum configured message size.", ex.Status.Detail);
Assert.AreEqual(StatusCode.ResourceExhausted, ex.StatusCode);
}
public void ReadStringValue_Numbers_NotString()
{
JsonTextReader reader = new JsonTextReader(new StringReader("[56,56]"));
reader.Read();
ExceptionAssert.Throws <JsonReaderException>(() =>
{
reader.ReadAsDateTime();
}, "Unexpected character encountered while parsing value: 5. Path '', line 1, position 2.");
ExceptionAssert.Throws <JsonReaderException>(() =>
{
reader.ReadAsDateTime();
}, "Unexpected character encountered while parsing value: 6. Path '', line 1, position 3.");
ExceptionAssert.Throws <JsonReaderException>(() =>
{
reader.ReadAsDateTime();
}, "Unexpected character encountered while parsing value: ,. Path '[0]', line 1, position 4.");
Assert.AreEqual(56, reader.ReadAsInt32());
Assert.IsTrue(reader.Read());
}
public async Task ReadSingleMessageAsync_AdditionalData_ThrowError()
{
// Arrange
var ms = new MemoryStream(new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x10,
0x10 // additional data
});
var pipeReader = PipeReader.Create(ms);
// Act
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(
() => pipeReader.ReadSingleMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualDeserializer).AsTask()).DefaultTimeout();
// Assert
Assert.AreEqual("Additional data after the message received.", ex.Status.Detail);
Assert.AreEqual(StatusCode.Internal, ex.StatusCode);
}
public async Task AsyncClientStreamingCall_DeadlineDuringWrite_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var stream = new SyncPointMemoryStream();
var content = new StreamContent(stream);
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content, grpcStatusCode: null)));
});
var systemClock = new TestSystemClock(DateTime.UtcNow);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: systemClock);
var deadline = systemClock.UtcNow.AddMilliseconds(0.1);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: deadline));
systemClock.UtcNow = deadline;
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode);
Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode);
}
public async Task Unary_DeadlineExceedBeforeServerCall_Failure()
{
var callCount = 0;
var tcs = new TaskCompletionSource <DataMessage>(TaskCreationOptions.RunContinuationsAsynchronously);
Task <DataMessage> UnaryFailure(DataMessage request, ServerCallContext context)
{
callCount++;
return(tcs.Task);
}
// Arrange
var method = Fixture.DynamicGrpc.AddUnaryMethod <DataMessage, DataMessage>(UnaryFailure);
var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig(retryableStatusCodes: new List <StatusCode> {
StatusCode.DeadlineExceeded
});
var channel = CreateChannel(serviceConfig: serviceConfig);
var client = TestClientFactory.Create(channel, method);
// Act
var call = client.UnaryCall(new DataMessage(), new CallOptions(deadline: DateTime.UtcNow));
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode);
Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode);
Assert.AreEqual(0, callCount);
AssertHasLog(LogLevel.Debug, "RetryEvaluated", "Evaluated retry for failed gRPC call. Status code: 'DeadlineExceeded', Attempt: 1, Retry: False");
AssertHasLog(LogLevel.Debug, "CallCommited", "Call commited. Reason: DeadlineExceeded");
tcs.SetResult(new DataMessage());
}
public void Constructor3ThrowsWithNullFormatters()
{
TestDataAssert.Execute(
TestData.RepresentativeValueAndRefTypeTestDataCollection,
(type, obj) =>
{
foreach (HttpMethod httpMethod in HttpTestData.AllHttpMethods)
{
foreach (Uri uri in TestData.UriTestData)
{
ExceptionAssert.ThrowsArgumentNull <TargetInvocationException>(
"formatters",
() =>
{
HttpRequestMessage request = GenericTypeAssert.InvokeConstructor <HttpRequestMessage>(
httpRequestMessageOfTType,
type,
new Type[] { type, typeof(HttpMethod), typeof(Uri), typeof(IEnumerable <MediaTypeFormatter>) },
new object[] { obj, httpMethod, uri, null });
});
}
}
});
}
public async Task ParseAdditionalContent_TextAsync()
{
string json = @"[
""Small"",
""Medium"",
""Large""
]content";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
#if DEBUG
reader.SetCharBuffer(new char[2]);
#endif
await reader.ReadAsync();
Assert.AreEqual(1, reader.LineNumber);
await reader.ReadAsync();
Assert.AreEqual(2, reader.LineNumber);
await reader.ReadAsync();
Assert.AreEqual(3, reader.LineNumber);
await reader.ReadAsync();
Assert.AreEqual(4, reader.LineNumber);
await reader.ReadAsync();
Assert.AreEqual(5, reader.LineNumber);
await ExceptionAssert.ThrowsAsync <JsonReaderException>(async() => { await reader.ReadAsync(); }, "Additional text encountered after finished reading JSON content: c. Path '', line 5, position 1.");
}
public void CreateTableWithoutIndexesTest()
{
var db = new OrmTestSession();
// the table
db.CreateTable <IndexedTable>(false);
// the indexes
var map = db.GetMapping <IndexedTable>();
foreach (var index in map.Indexes)
{
db.Execute(index.GetCreateSql(map.TableName));
}
// the test
db.Insert(new IndexedTable {
Indexed = 1
});
ExceptionAssert.Throws <SqliteException>(
() => db.Insert(new IndexedTable {
Indexed = 1
}));
}
public void MissingDotAfterIndexer()
{
ExceptionAssert.Throws <JsonException>(() => { new JPath("[1]Blah"); }, "Unexpected character following indexer: B");
}
public void Constructor_Throws_WhenResponsesAreNull()
{
// Arrange & Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => CreateBatchContent(null), "responses");
}
public void IndexerCloseInProperty()
{
ExceptionAssert.Throws <JsonException>(() => { new JPath("]"); }, "Unexpected character while parsing path: ]");
}
