public static void NullJsonThrows()
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(() => JsonSerializer.Deserialize(json: null, returnType: typeof(string)));
Assert.Contains("json", ex.ToString());
ex = Assert.Throws <ArgumentNullException>(() => JsonSerializer.DeserializeAsync(utf8Json: null, returnType: null));
Assert.Contains("utf8Json", ex.ToString());
}
public void TestCompareToNullThrowsException()
{
// ARRANGE
IAxiom axiom = new Axiom();
ICard topCard = new Card(Colour.Green, Number.Four, axiom);
const int numberOfCards = 4;
IRuleScore ruleScore = new RuleScore(numberOfCards, topCard);
// ACT
ArgumentNullException argumentNullException = null;
int comparison = 99;
try
{
comparison = ruleScore.CompareTo(null);
}
catch (ArgumentNullException exception)
{
argumentNullException = exception;
}
// ASSERT
if (argumentNullException != null)
{
Console.WriteLine(argumentNullException.ToString());
}
Assert.IsNotNull(argumentNullException);
Assert.AreEqual(expected: 99, actual: comparison);
}
public void TestAddNullCardThrowsArgumentNullException()
{
// ARRANGE
IAxiom axiom = new Axiom();
ICanvas canvas = new Canvas(axiom);
// ACT
ArgumentNullException argumentNullException = null;
try
{
canvas.AddCard(null);
}
catch (ArgumentNullException ex)
{
argumentNullException = ex;
}
if (argumentNullException != null)
{
Console.WriteLine(argumentNullException.ToString());
}
// ASSERT
Assert.IsNotNull(argumentNullException);
}
public void Connect(IConnection connection, string ip, int port, ISerializer serializer)
{
if (streamContainer == null)
{
ArgumentNullException ex = new ArgumentNullException("StreamContainer was not set.");
Logger.Instance.WriteLog("Failed at connection: " + ex.ToString());
throw ex;
}
if (streamContainer.StreamExist("NetworkStream"))
{
ArgumentException ex = new ArgumentException("Stream already exist.");
Logger.Instance.WriteLog("Trying to connect when a stream has already been established.");
throw ex;
}
this.connection = connection;
connection.Connect(ip, port);
if (connection.fetchStream() == null)
{
ArgumentNullException ex = new ArgumentNullException("No stream found when fetching.");
Logger.Instance.WriteLog("Failed at connection stream retreival: " + ex.ToString());
throw ex;
}
streamContainer.Add("NetworkStream", connection.fetchStream(), serializer);
connection.AddObserver(listener);
connection.AddObserver(this);
listener.Start(streamContainer.Retrieve("NetworkStream"));
}
private static void ThrowArgumentNullException(DomainLogger logger, string tag, string message)
{
var ex = new ArgumentNullException(message);
logger.E(tag, ex.ToString() ?? "");
throw ex;
}
public void TestAddNullCardThrowsAnException()
{
// ARRANGE
IAxiom axiom = new Axiom();
IList <ICard> cards = new List <ICard>
{
new Card(Colour.Orange, Number.Three, axiom),
new Card(Colour.Blue, Number.Seven, axiom),
new Card(Colour.Red, Number.One, axiom)
};
IPalette palette = new Palette(cards);
// ACT
ArgumentNullException argumentNullException = null;
try
{
palette.AddCard(null);
}
catch (ArgumentNullException ex)
{
argumentNullException = ex;
}
// ASSERT
if (argumentNullException != null)
{
Console.WriteLine(argumentNullException.ToString());
}
Assert.IsNotNull(argumentNullException, "Expected exception not thrown");
}
public void TestArgumentNullExceptionWithEmptyCstor()
{
var referenceException = new ArgumentNullException();
var exceptionUnderTest = new SystemZZZ.ArgumentNullException();
Assert.AreEqual(referenceException.Message, exceptionUnderTest.Message);
Assert.AreEqual(referenceException.ToString(), exceptionUnderTest.ToString().Replace("ZZZ", ""));
}
public void AddSerializer(ISerializer serializer)
{
if (serializer == null)
{
ArgumentNullException ex = new ArgumentNullException("Seralizer is null.");
Logger.Instance.WriteLog("UDP Add Seralizer: " + ex.ToString());
throw ex;
}
this.serializer = serializer;
}
public static void NullReturnTypeThrows()
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(() =>
{
Utf8JsonReader reader = default;
JsonSerializer.Deserialize(ref reader, returnType: null);
});
Assert.Contains("returnType", ex.ToString());
ex = Assert.Throws <ArgumentNullException>(() => JsonSerializer.Deserialize("", returnType: null));
Assert.Contains("returnType", ex.ToString());
ex = Assert.Throws <ArgumentNullException>(() => JsonSerializer.Deserialize(new byte[] { 1 }, returnType: null));
Assert.Contains("returnType", ex.ToString());
ex = Assert.Throws <ArgumentNullException>(() => JsonSerializer.DeserializeAsync(new MemoryStream(), returnType: null));
Assert.Contains("returnType", ex.ToString());
}
public TcpServerClient(Socket socket)
{
if (socket == null)
{
ArgumentNullException ex = new ArgumentNullException("socket is null.");
Logger.Instance.WriteLog("UDP stream creation: " + ex.ToString());
throw ex;
}
stream = new NetworkStream(socket);
}
public Stream fetchStream()
{
if (stream == null)
{
ArgumentNullException ex = new ArgumentNullException("Udp stream is null.");
Logger.Instance.WriteLog("Cannot fetch stream : " + ex.ToString());
throw ex;
}
return(stream);
}
public Client(StreamContainer container)
{
if (container == null)
{
ArgumentNullException ex = new ArgumentNullException();
Logger.Instance.WriteLog("Failed at client init: " + ex.ToString());
throw ex;
}
streamContainer = container;
}
public Client(IClientListener listener)
{
if (listener == null)
{
ArgumentNullException ex = new ArgumentNullException();
Logger.Instance.WriteLog("Failed at client init: " + ex.ToString());
throw ex;
}
this.listener = listener;
}
public static T MustNotBeNull <T>([NotNull] DomainLogger logger, [NotNull] string tag, [NotNull] string argumentName, T argumentValue) where T : class
{
Debug.Assert(argumentValue != null);
if (argumentValue == null)
{
var ex = new ArgumentNullException(argumentName);
logger.E(tag, ex.ToString() ?? "");
throw ex;
}
return(argumentValue);
}
public static unsafe void *MustNotBeNullPointer([NotNull] DomainLogger logger, [NotNull] string tag, [NotNull] string argumentName, void *argumentValue)
{
Debug.Assert(argumentValue != null);
if (argumentValue == null)
{
var ex = new ArgumentNullException(argumentName);
logger.E(tag, ex.ToString() ?? "");
throw ex;
}
return(argumentValue);
}
internal BestAvailableCompany FindSpecificCompany(string market, CreateReportOrder createReportOrder, string orderCompanyKey = null, int?orderFleetId = null, double?latitude = null, double?longitude = null)
{
if (!orderCompanyKey.HasValue() && !orderFleetId.HasValue)
{
Exception createOrderException = new ArgumentNullException("You must at least provide a value for orderCompanyKey or orderFleetId");
createReportOrder.Error = createOrderException.ToString();
_commandBus.Send(createReportOrder);
throw createOrderException;
}
var homeCompanyKey = _serverSettings.ServerData.TaxiHail.ApplicationKey;
var fleets = market.HasValue()
? _taxiHailNetworkServiceClient.GetMarketFleets(homeCompanyKey, market).ToArray()
: _taxiHailNetworkServiceClient.GetNetworkFleet(homeCompanyKey, latitude, longitude).ToArray();
if (orderCompanyKey.HasValue())
{
var match = fleets.FirstOrDefault(f => f.CompanyKey == orderCompanyKey);
if (match != null)
{
return(new BestAvailableCompany
{
CompanyKey = match.CompanyKey,
CompanyName = match.CompanyName,
FleetId = match.FleetId
});
}
}
if (orderFleetId.HasValue)
{
var match = fleets.FirstOrDefault(f => f.FleetId == orderFleetId.Value);
if (match != null)
{
return(new BestAvailableCompany
{
CompanyKey = match.CompanyKey,
CompanyName = match.CompanyName,
FleetId = match.FleetId
});
}
}
// Nothing found
return(new BestAvailableCompany());
}
public void FormatReturnsValueWithException()
{
var config = new LoggingConfig();
var scopeLevel = 1;
var categoryName = Guid.NewGuid().ToString();
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
var message = Guid.NewGuid().ToString();
var exception = new ArgumentNullException(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
var sut = new DefaultFormatter(config);
var actual = sut.Format(scopeLevel, categoryName, logLevel, eventId, message, exception);
_output.WriteLine(actual);
actual.Should().Contain(exception.ToString());
}
public void Given_ArgumentNullExceptionArgument_When_WriteLogEntryWithLogLevelErrorAndCallerName_Then_LogStringContainsErrorAndTestMessageAndArgumentNullException()
{
var writer = new StringWriter();
Console.SetOut(writer);
//When
var expectedException = new ArgumentNullException();
m_NLogMessageWriter.WriteLogEntry(LogLevel.Error, TestMessage, MethodBase.GetCurrentMethod().Name, expectedException);
var logString = writer.ToString();
Debug.WriteLine(logString);
//Then
var logColumns = logString.Split('|');
Assert.AreEqual(LogLevel.Error.ToString().ToUpper() + ":", logColumns[2].Trim());
Assert.AreEqual(TestMessage(), logColumns[6].Trim());
Assert.IsTrue(logColumns[7].Contains(expectedException.ToString()));
}
public void TestLogEventNetDataContractSerializationWithoutException()
{
DateTime now = DateTime.Now;
ArgumentNullException nullException = new ArgumentNullException("RandomParameter");
LoggingEventData data = new LoggingEventData();
data.Domain = Environment.UserDomainName;
data.Level = Level.Error;
data.Message = "Test Message";
data.ThreadName = "1234";
data.UserName = Environment.UserName;
data.TimeStamp = now;
data.Identity = @"someone\somewhere";
data.ExceptionString = nullException.ToString();
LoggingEvent ev = new LoggingEvent(data);
MemoryStream ms = new MemoryStream();
NetDataContractSerializer serializer = new NetDataContractSerializer();
serializer.Serialize(ms, ev);
ms.Position = 0;
var ev2 = serializer.Deserialize(ms);
Assert.IsInstanceOfType(ev2, typeof(LoggingEvent));
LoggingEvent ev2Casted = (LoggingEvent)ev2;
Assert.AreEqual(ev.Domain, ev2Casted.Domain);
Assert.AreEqual(ev.Level, ev2Casted.Level);
Assert.AreEqual(ev.MessageObject, ev2Casted.MessageObject);
Assert.AreEqual(ev.RenderedMessage, ev2Casted.RenderedMessage);
Assert.AreEqual(ev.ThreadName, ev2Casted.ThreadName);
Assert.AreEqual(ev.TimeStamp, ev2Casted.TimeStamp);
Assert.AreEqual(ev.Identity, ev2Casted.Identity);
Assert.AreEqual(ev.Domain, ev2Casted.Domain);
Assert.AreEqual(ev.UserName, ev2Casted.UserName);
}
public void LogWritesExceptionTest()
{
var logLevel = LogLevel.Information;
var eventId = Model.Create <EventId>();
var state = Guid.NewGuid().ToString();
var message = Guid.NewGuid().ToString();
var exception = new ArgumentNullException(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
string Formatter(string logState, Exception?error) => message;
var categoryName = Guid.NewGuid().ToString();
var output = Substitute.For <ITestOutputHelper>();
var sut = new TestOutputLogger(categoryName, output);
sut.Log(logLevel, eventId, state, exception, Formatter);
output.Received(1).WriteLine(Arg.Any <string>());
output.Received()
.WriteLine(Arg.Is <string>(x => x.Contains(exception.ToString(), StringComparison.OrdinalIgnoreCase)));
}
public void ReceiveClients()
{
while (_running)
{
if (listener == null || serializer == null || clientList == null)
{
ArgumentNullException ex = new ArgumentNullException();
Logger.Instance.WriteLog("Failed at Server recieve: " + ex.ToString());
throw ex;
}
IServerClient client = ServerClientCreator.CreateClient(listener, serverSettings.protocol);
clientList.Add(client);
foreach (IObserver o in observerList)
{
client.AddObserver(o);
}
client.AddSerializer(serializer);
client.Run();
Console.WriteLine("Client Connected to Server");
client.Send("Conencted");
}
}
public void TestConstructorWithNullListOfCardsThrowsException()
{
// ACT
ArgumentNullException argumentNullException = null;
IPalette palette = null;
try
{
palette = new Palette(null);
}
catch (ArgumentNullException ex)
{
argumentNullException = ex;
}
// ASSERT
if (argumentNullException != null)
{
Console.WriteLine(argumentNullException.ToString());
}
Assert.IsNotNull(argumentNullException, "argumentNullException != null");
Assert.IsNull(palette, "palette == null");
}
public void PickTopCardFromNullListThrowsArgumentNullException()
{
// ACT
ArgumentNullException argumentNullException = null;
ICard topCard = null;
try
{
topCard = Card.TopCard(null);
}
catch (ArgumentNullException ex)
{
argumentNullException = ex;
}
if (argumentNullException != null)
{
Console.WriteLine(argumentNullException.ToString());
}
// ASSERT
Assert.IsNotNull(argumentNullException);
Assert.IsNull(topCard);
}
private void __CoAsynSendRequestRunning(RequestCommunicatePackage communicator)
{
RequestPackage reqtPkg = new RequestPackage(_selfDevice,
communicator.CommunicationName,
communicator.WaitResponse,
communicator.ParamPackage.ParamDefalutValues);
C2CRequestPackage c2cReqtPkg = new C2CRequestPackage(_selfDevice,
"outside message sent",
communicator.WaitResponse,
null);
c2cReqtPkg.OutSideMessage = reqtPkg;
RequestMTPackage mtReqtPkg = new RequestMTPackage(c2cReqtPkg,
_selfDevice,
communicator.TargetDevice,
c2cReqtPkg.WaittingResponse);
if (communicator.WaitResponse)
{
MiddlewareTransferPackage mtReplyBasePkg = null;
try
{
//100s limited time to wait this c2c response.
mtReplyBasePkg = _middlewareCommunicateProcessor.SynSendMessage(mtReqtPkg, 10000);
}
catch (System.Exception ex)
{
//throw new MiddlewareCommunicatErrorExcetion(ex.ToString());
this.CoMiddleware2MiddlewareAsynReqtCommunicatErrorRecived_OutsideNotify(communicator,
new MiddlewareCommunicatErrorExcetion(ex.ToString()));
}
if (null != (mtReplyBasePkg as ReplyMTPackage))
{
ReplyMTPackage mtReplyPkg = mtReplyBasePkg as ReplyMTPackage;
C2CReplyPackage c2cReplyPkg = mtReplyPkg.C2CReplyPackage;
if ((null != c2cReplyPkg) && (null != c2cReplyPkg.OutSideMessage))
{
ReplyPackage outsideReplyPkg = c2cReplyPkg.OutSideMessage;
communicator.ResponsePackage = outsideReplyPkg;
//asyn outside notify
if (null != communicator.AsynchronousReponseCame)
{
communicator.AsynchronousReponseCame(communicator, new AsynReplyCommunicatePackage(outsideReplyPkg));
}
}
else
{
ArgumentNullException ex = new ArgumentNullException("应答报文C2CReplyPackage/C2CReplyPackage.OutSideMessage字段空");
this.CoMiddleware2MiddlewareAsynReqtCommunicatErrorRecived_OutsideNotify(communicator,
new MiddlewareCommunicatErrorExcetion(ex.ToString()));
}
}
else
{
NotImplementedException ex = new NotImplementedException("暂不支持打回RequestMTPackage类型");
this.CoMiddleware2MiddlewareAsynReqtCommunicatErrorRecived_OutsideNotify(communicator,
new MiddlewareCommunicatErrorExcetion(ex.ToString()));
}
}
else
{
try
{
_middlewareCommunicateProcessor.AsynSendMessage(mtReqtPkg);
}
catch (System.Exception ex)
{
//throw new MiddlewareCommunicatErrorExcetion(ex.ToString());
this.CoMiddleware2MiddlewareAsynReqtCommunicatErrorRecived_OutsideNotify(communicator,
new MiddlewareCommunicatErrorExcetion(ex.ToString()));
}
}
}
/// <summary>
/// This is the method called from the other AppDomain to run the transformation
/// </summary>
public string PerformTransformation()
{
string result = Resources.ErrorOutput;
if (assembly == null)
{
LogError(Resources.ErrorInitializingTransformationObject, false);
return(result);
}
dynamic val = null;
try
{
val = CreateTextTransformation(session.ClassFullName, host, assembly, session.UserTransformationSession, session.BaseClassName);
if (val != null)
{
try
{
val.Initialize();
}
catch (RuntimeBinderException arg)
{
LogError(Resources.InvalidBaseClass + string.Format(CultureInfo.CurrentCulture, Resources.Exception, arg), false);
}
catch (Exception ex)
{
if (Engine.IsCriticalException(ex))
{
throw;
}
LogError(Resources.ErrorInitializingTransformationObject + string.Format(CultureInfo.CurrentCulture, Resources.Exception, ex), false);
}
try
{
if (!val.Errors.HasErrors && !Errors.HasErrors)
{
try
{
result = val.TransformText();
}
catch (RuntimeBinderException arg2)
{
LogError(Resources.InvalidBaseClass + string.Format(CultureInfo.CurrentCulture, Resources.Exception, arg2), false);
}
catch (Exception innerException)
{
if (Engine.IsCriticalException(innerException))
{
throw;
}
if (innerException.InnerException != null)
{
innerException = innerException.InnerException;
}
if (innerException.Data["TextTemplatingProgress"] != null)
{
result = innerException.Data["TextTemplatingProgress"].ToString();
}
ArgumentNullException ex2 = innerException as ArgumentNullException;
if (ex2 != null && StringComparer.OrdinalIgnoreCase.Compare(ex2.ParamName, "objectToConvert") == 0)
{
int lineNum = 0;
string filename = session.TemplateFile;
if (session.Debug && !TryParseStackTrace(ex2.StackTrace, out lineNum, out filename))
{
filename = session.TemplateFile;
}
LogError(Resources.ExpressionBlockNull + Environment.NewLine + ex2.ToString(), false, filename, lineNum, 0);
}
else
{
int lineNum2 = 0;
string filename2 = session.TemplateFile;
if (session.Debug && !TryParseStackTrace(innerException.StackTrace, out lineNum2, out filename2))
{
filename2 = session.TemplateFile;
}
LogError(Resources.TransformationErrorPrepend + innerException.ToString(), false, filename2, lineNum2, 0);
}
}
}
foreach (dynamic item in val.Errors)
{
item.ErrorText = Resources.TransformationErrorPrepend + item.ErrorText;
Type type = item.GetType();
if (type.IsEquivalentTo(typeof(CompilerError)))
{
Errors.Add(item);
}
else
{
Errors.Add(new CompilerError(item.FileName, item.Line, item.Column, item.ErrorNumber, item.ErrorText));
}
}
return(result);
}
catch (RuntimeBinderException arg3)
{
LogError(Resources.InvalidBaseClass + string.Format(CultureInfo.CurrentCulture, Resources.Exception, arg3), false);
return(result);
}
}
return(result);
}
catch (Exception ex3)
{
if (Engine.IsCriticalException(ex3))
{
throw;
}
LogError(Resources.ExceptionWhileRunningCode + string.Format(CultureInfo.CurrentCulture, Resources.Exception, ex3), false);
return(result);
}
finally
{
(val as IDisposable)?.Dispose();
assembly = null;
host = null;
session = null;
}
}
/// <summary>
/// 添加操作
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Response <string> AddasnAndasnDetailSF(AddASNandASNDetailRequest request)
{
Response <string> response = new Response <string>();
string message = "";
if (request == null || request.asn == null || !request.asn.Any())
{
ArgumentNullException ex = new ArgumentNullException("AddasnAndasnDetail request");
LogError(ex);
response.ErrorCode = ErrorCode.Argument;
response.Exception = ex;
response.Result = ex.ToString();
response.IsSuccess = false;
return(response);
}
try
{
//判断明细中同一外部单号中是否存在相同的sku 如果存在就提示
DataTable dt = request.asnDetails.ToDataTable();
if (request.asn.Select(c => c.CustomerID).ToArray().FirstOrDefault() != 71)
{//永兴判断
var dt1 = from t in dt.AsEnumerable()
group t by new { t1 = t.Field <string>("ExternReceiptNumber"), t2 = t.Field <string>("SKU"), UPC = t.Field <string>("UPC"), t3 = t.Field <string>("BoxNumber"), t4 = t.Field <string>("BatchNumber"), t5 = t.Field <string>("Unit"), t6 = t.Field <string>("Specifications") } into m
select new
{
SKU = m.Select(p => p.Field <string>("SKU")).First(),
UPC = m.Select(p => p.Field <string>("UPC")).First(),
ExternReceiptNumber = m.Select(p => p.Field <string>("ExternReceiptNumber")).First(),
BoxNumber = m.Select(p => p.Field <string>("BoxNumber")).First(),
BatchNumber = m.Select(p => p.Field <string>("BatchNumber")).First(),
Unit = m.Select(p => p.Field <string>("Unit")).First(),
Specifications = m.Select(p => p.Field <string>("Specifications")).First(),
count = m.Count(),
};
var dr1 = dt1.Where(c => c.count > 1);
var results = "";
if (request.asn.Select(c => c.CustomerID).ToArray().FirstOrDefault() != 74 && request.asn.Select(c => c.CustomerID).ToArray().FirstOrDefault() != 75)
{
//if (dr1.Count() > 0)
//{
// foreach (var item in dr1)
// {
// results += "<p><font color='#FF0000'>外部单号" + item.ExternReceiptNumber + "中的SKU" + item.SKU + "存在重复值！" + "</font></p>";
// }
// response.Result = results;
// response.IsSuccess = false;
// return response;
//}
}
}//永兴判断
message = new ASNManagementAccessor().AddasnAndasnDetailSF(request);
if (message.Contains("添加成功") || message == "")
{
response.Result = message;
response.IsSuccess = true;
}
else
{
response.Result = message;
response.IsSuccess = false;
}
}
catch (Exception ex)
{
LogError(ex);
response.IsSuccess = false;
response.Result = ex.ToString();
response.ErrorCode = ErrorCode.Technical;
}
return(response);
}
