public CharacterTransformer(ILogger <RowTransformerBase <CharacterRow, Character> > logger) : base(logger)
{
//prepare converters so we only need one instance no matter how many rows are processed
_intConverter = new IntConverter();
_stringToBooleanConverter = new StringToBooleanConverter();
_realmConverter = new TypeListConverter(new RealmList());
}
public void ConvertToCsvItemTest()
{
var c = new IntConverter();
Assert.AreEqual("1000", c.ConvertToCsvItem(CreateConvertToCsvItemContext(1000)));
Assert.AreEqual("1,000", c.ConvertToCsvItem(CreateConvertToCsvItemContext(1000, "FormattedValue")));
}
/// <summary>
/// 棋力を文字列化します。
/// </summary>
public static string ToString(SkillLevel skillLevel)
{
if (!string.IsNullOrEmpty(skillLevel.OriginalText))
{
var text = skillLevel.OriginalText;
return(text.Length > 12 ?
text.Substring(0, 12) :
text);
}
var n = IntConverter.Convert(NumberType.Grade, skillLevel.Grade);
switch (skillLevel.Kind)
{
case SkillKind.Kyu:
return(n + "級");
case SkillKind.Dan:
return(n + "段");
case SkillKind.Unknown:
return("");
}
return("");
}
/// <summary>
/// 駒の描画を行います。
/// </summary>
private void AddRenderPiece(RenderBuffer renderBuffer, BoardPiece piece,
int count, PointF cpos, double zorder)
{
if (this.pieceTexture == null || !this.pieceTexture.IsAvailable)
{
return;
}
if (count <= 0)
{
return;
}
var s = SquareSize;
var bounds = new RectangleF(
cpos.X - s.Width / 2, cpos.Y - s.Height / 2,
s.Width, s.Height);
// 駒自体の描画を行います。
renderBuffer.AddRender(
this.pieceTexture, BlendType.Diffuse,
bounds, Transform, GetPieceMesh(piece), zorder);
// 必要なら持ち駒の数も描画します。
if (count >= 2)
{
var text = IntConverter.Convert(NumberType.Big, count);
bounds = new RectangleF(
cpos.X - s.Width * 0.1f, cpos.Y - s.Height * 0.6f,
s.Width * 0.8f, s.Height * 0.5f);
AddRenderText(
renderBuffer, text, this.pieceCountFont,
bounds, zorder + 0.05);
}
}
public void IntConverterFromDecimal()
{
var converter = new IntConverter();
var result = converter.Convert(77.5m);
Assert.AreEqual(78, result);
}
public void ToStreamTest()
{
IntConverter target = new IntConverter();
Assert.AreEqual<string>("0001", target.ToStream(1));
Assert.AreEqual<string>("0002", target.ToStream(2));
Assert.AreEqual<string>("0003", target.ToStream(3));
}
public SettingsWindow(ServiceBuilder serviceBuilder, HotKeysBuilder hotKeysBuilder)
{
InitializeComponent();
serverPortConverter = new IntConverter();
clientPortConverter = new IntNullableConverter()
{
AutoParseNullOrWhiteSpace = true,
NullOrWhiteSpaceValue = null
};
timMode.DataContext = ServiceBuilder = serviceBuilder;
timHotKeys.DataContext = HotKeysBuilder = hotKeysBuilder;
if (serviceBuilder.BuildServer)
{
tbxPort.Text = serverPortConverter.Convert(serviceBuilder.ServerPort);
}
else if (serviceBuilder.BuildClient)
{
tbxPort.Text = clientPortConverter.Convert(serviceBuilder.ClientPort);
}
else
{
tbxPort.Text = "1884";
}
if (string.IsNullOrWhiteSpace(ServiceBuilder.ServerAddress))
{
ServiceBuilder.ServerAddress = "127.0.0.1";
}
}
public SettingsWindow(ServiceBuilder serviceBuilder, HotKeysBuilder hotKeysBuilder)
{
InitializeComponent();
serverPortConverter = new IntConverter();
clientPortConverter = new IntNullableConverter()
{
AutoParseNullOrWhiteSpace = true,
NullOrWhiteSpaceValue = null
};
timMode.DataContext = ServiceBuilder = serviceBuilder;
timHotKeys.DataContext = HotKeysBuilder = hotKeysBuilder;
if (serviceBuilder.BuildServer)
{
tbxPort.Text = serverPortConverter.Convert(serviceBuilder.ServerPort);
}
else if (serviceBuilder.BuildClient)
{
tbxPort.Text = clientPortConverter.Convert(serviceBuilder.ClientPort);
}
if (!serviceBuilder.IsSearchShuffle.HasValue)
{
cbxSearchShuffle.IsChecked = null;
}
if (!serviceBuilder.Play.HasValue)
{
cbxPlay.IsChecked = null;
}
}
private int?ConvertToObjectItem(string csvItem)
{
var c = new IntConverter();
Assert.IsTrue(c.TryConvertToObjectItem(CreateConvertToObjectItemContext(csvItem), out object?result, out string _));
return((int?)result);
}
static void Main(string[] args)
{
int x = 11;
Console.WriteLine(IntConverter.MultiplByTen(x));
Console.ReadKey();
}
public void IntConverterFromDecimalTooSmall()
{
var converter = new IntConverter();
var result = converter.Convert(decimal.MinValue);
Assert.AreEqual(null, result);
}
public void should_convert_from_string()
{
var converter = new IntConverter();
var result = converter.ConvertFromString("10", Mock.Of <IReaderRow>(), null);
result.Should().Be(10);
}
public void should_convert_none_literal_to_nullable_int()
{
var converter = new IntConverter();
var result = converter.ConvertFromString(TimetableLiterals.None, Mock.Of <IReaderRow>(), null);
result.Should().BeNull();
}
private string GetValueText(Score score)
{
return(
IsValueFullWidth ?
IntConverter.Convert(NumberType.Big, score.Value) :
score.Value.ToString());
}
public void ToObjectTest()
{
IntConverter target = new IntConverter();
Assert.AreEqual<int>(1, target.ToObject("0001"));
Assert.AreEqual<int>(2, target.ToObject("0002"));
Assert.AreEqual<int>(3, target.ToObject("0003"));
}
public void IntConverter(object input, int?expected)
{
var converter = new IntConverter();
var result = converter.Convert(input);
Assert.AreEqual(expected, result);
}
internal override void CalculateReturnValue()
{
if (IntConverter == null)
{
throw new NullReferenceException();
}
else
{
if (modbusValueData.Values.Count > 1)
{
int indexno = 0;
ushort[] values = new ushort[2];
foreach (var item in base.modbusValueData.Values)
{
values[indexno] = item;
indexno++;
if (indexno == 2)
{
break;
}
}
InnerValue = IntConverter.ConvertToUint(values[0], values[1]);
}
else
{
throw new IndexOutOfRangeException();
}
}
}
private void _InternalDoPersistLarge(Revenj.Utility.ChunkedMemoryStream cms, global::UseCase1.Customer[] insertedData, List <KeyValuePair <global::UseCase1.Customer, global::UseCase1.Customer> > updatedData, global::UseCase1.Customer[] deletedData)
{
var dbq = DatabaseQuery as IPostgresDatabaseQuery;
if (insertedData.Length > 0)
{
dbq.BulkInsert(
"\"UseCase1\".\">tmp-Customer-insert<\"",
insertedData.Select((item, ind) => new IPostgresTuple[] { IntConverter.ToTuple(ind), _DatabaseCommon.FactoryUseCase1_Customer.CustomerConverter.CreateRecordTupleFrom(item, _DatabaseCommon.FactoryUseCase1_Customer.CustomerConverter.TableTuples) }));
}
if (updatedData.Count > 0)
{
dbq.BulkInsert(
"\"UseCase1\".\">tmp-Customer-update<\"",
updatedData.Select((kv, ind) => new IPostgresTuple[] { IntConverter.ToTuple(ind), _DatabaseCommon.FactoryUseCase1_Customer.CustomerConverter.CreateRecordTupleFrom(kv.Key, _DatabaseCommon.FactoryUseCase1_Customer.CustomerConverter.PrimaryKeyUpdateTuples), _DatabaseCommon.FactoryUseCase1_Customer.CustomerConverter.CreateRecordTupleFrom(kv.Value, _DatabaseCommon.FactoryUseCase1_Customer.CustomerConverter.TableTuples) }));
}
if (deletedData.Length > 0)
{
dbq.BulkInsert(
"\"UseCase1\".\">tmp-Customer-delete<\"",
deletedData.Select((item, ind) => new IPostgresTuple[] { IntConverter.ToTuple(ind), _DatabaseCommon.FactoryUseCase1_Customer.CustomerConverter.CreateRecordTupleFrom(item, _DatabaseCommon.FactoryUseCase1_Customer.CustomerConverter.PrimaryKeyDeleteTuples) }));
}
var sw = cms.GetWriter();
sw.Write("/*NO LOAD BALANCE*/SELECT \"UseCase1\".\"persist_Customer_internal\"(");
sw.Write(updatedData.Count);
sw.Write(", ");
sw.Write(deletedData.Length);
sw.Write(")");
sw.Flush();
cms.Position = 0;
var com = PostgresCommandFactory.NewCommand(cms, "SELECT \"UseCase1\".\"persist_Customer_internal\"(:updated_count,:deleted_count)");
string _sqlError = null;
DatabaseQuery.Execute(com, dr => _sqlError = dr.GetString(0));
if (_sqlError != null)
{
throw new PostgresException(_sqlError);
}
foreach (var item in insertedData)
{
item.__ResetChangeTracking();
}
foreach (var item in updatedData)
{
item.Value.__ResetChangeTracking();
}
}
public void TryConvertToObjectItemRequireTest()
{
var c = new IntConverter();
var context = CreateConvertToObjectItemContext(string.Empty);
Assert.IsFalse(c.TryConvertToObjectItem(context, out object?_, out string message));
Assert.AreEqual(CsvConfig.Current.ValidationMessage.GetRequiredError(context), message);
}
public ushort[] GetWriteValue()
{
if (IntConverter == null)
{
throw new NullReferenceException();
}
return(IntConverter.ConvertToUshort(WriteValue));
}
public static int NullableIntegerToURI(char[] buf, int pos, int?value)
{
if (value == null)
{
return(pos);
}
return(IntConverter.Serialize(value.Value, buf, pos));
}
public void TryConvertToObjectItemFailureTest()
{
var c = new IntConverter();
var context = CreateConvertToObjectItemContext("x");
Assert.IsFalse(c.TryConvertToObjectItem(context, out object?_, out string message));
Assert.AreEqual(CsvConfig.Current.ValidationMessage.GetNumericConvertError(context), message);
}
public EventTransformer(ILogger <RowTransformerBase <EventRow, Event> > logger) : base(logger)
{
//prepare converters so we only need one instance
_dateConverter = new DateConverter();
_intConverter = new IntConverter();
_realmConverter = new TypeListConverter(new RealmList());
_eventTypeConverter = new TypeListConverter(new EventTypeList());
}
/// <summary>
/// 盤の描画を行います。
/// </summary>
private void AddRenderBoard(RenderBuffer renderBuffer)
{
// 盤
renderBuffer.AddRender(
this.boardTexture, BlendType.Diffuse,
BoardBounds, Transform,
ShogiZOrder.BoardZ, BoardOpacity);
// 上部に描画する盤の符号の領域
var totalBounds = RectangleF.FromLTRB(
BoardSquareBounds.Left,
BoardBounds.Top,
BoardSquareBounds.Right,
BoardSquareBounds.Top); // Topはミスではありません。
var w = totalBounds.Width / Board.BoardSize;
for (int n = 1; n <= Board.BoardSize; ++n)
{
// 符号を描画する領域
var bounds = new RectangleF(
totalBounds.Left + w * (n - 1),
totalBounds.Top,
w,
totalBounds.Height);
bounds.Inflate(0, -2.5f);
var str = IntConverter.Convert(
NumberType.Big,
ViewSide == BWType.Black ? 10 - n : n);
AddRenderText(
renderBuffer, str, this.boardSignFont,
bounds, ShogiZOrder.BoardZ);
}
// 右側に描画する盤の符号の領域
totalBounds = RectangleF.FromLTRB(
BoardSquareBounds.Right, // Rightはミスではありません。
BoardSquareBounds.Top,
BoardBounds.Right,
BoardSquareBounds.Bottom);
var h = totalBounds.Height / Board.BoardSize;
for (int n = 1; n <= Board.BoardSize; ++n)
{
// 符号を描画する領域
var bounds = new RectangleF(
totalBounds.Left,
totalBounds.Top + h * (n - 1),
totalBounds.Width,
w);
bounds.Inflate(-1.5f, 0);
var str = IntConverter.Convert(
NumberType.Kanji,
ViewSide == BWType.Black ? n : 10 - n);
AddRenderText(
renderBuffer, str, this.boardSignFont,
bounds, ShogiZOrder.BoardZ);
}
}
public void TestConvertTo(
[Values(1, 2, 3, 4, 10, 11, 12, 12, 12)] int input,
[Values(4, 5, 6)] int width
)
{
var converter = new IntConverter();
var output = converter.To(input, width);
Assert.True(output.EndsWith(input.ToString()));
}
public void CanSerializeAndDeserialize()
{
int value = int.MaxValue;
IntConverter converter = new IntConverter();
byte[] bytes = converter.Serialize(value);
int valueFromBytes = converter.Deserialize(bytes);
Assert.Equal(valueFromBytes, value);
}
public MagiciteTransformer(ILogger <RowTransformerBase <MagiciteRow, Magicite> > logger) : base(logger)
{
//prepare converters so we only need one instance no matter how many rows are processed
_intConverter = new IntConverter();
_doubleConverter = new DoubleConverter();
_stringToBooleanConverter = new StringToBooleanConverter();
_abilityTypeConverter = new TypeListConverter(new AbilityTypeList());
_autoTargetTypeConverter = new TypeListConverter(new AutoTargetTypeList());
_damageFormulaTypeConverter = new TypeListConverter(new DamageFormulaTypeList());
_elementConverter = new TypeListConverter(new ElementList());
_realmConverter = new TypeListConverter(new RealmList());
}
public OtherTransformer(ILogger <RowTransformerBase <OtherRow, Other> > logger) : base(logger)
{
//prepare converters so we only need one instance no matter how many rows are processed
_doubleConverter = new DoubleConverter();
_intConverter = new IntConverter();
_stringToBooleanConverter = new StringToBooleanConverter();
_abilityTypeConverter = new TypeListConverter(new AbilityTypeList());
_targetTypeConverter = new TypeListConverter(new TargetTypeList());
_autoTargetTypeConverter = new TypeListConverter(new AutoTargetTypeList());
_damageFormulaTypeConverter = new TypeListConverter(new DamageFormulaTypeList());
_elementConverter = new TypeListConverter(new ElementList());
_schoolConverter = new TypeListConverter(new SchoolList());
}
public void IntConverterTest()
{
Assert.That(IntConverter.Convert(233), Is.EqualTo("233"));
Assert.That(IntConverter.Convert(-233), Is.EqualTo("-233"));
Assert.That(IntConverter.Convert("444556"), Is.EqualTo(444556));
Assert.Throws(typeof(FieldConvertError), delegate { IntConverter.Convert("+100"); });
Assert.Throws(typeof(FieldConvertError), delegate { IntConverter.Convert("(100)"); });
Assert.Throws(typeof(FieldConvertError), delegate { IntConverter.Convert("AB"); });
Assert.Throws(typeof(FieldConvertError), delegate { IntConverter.Convert("2.3234"); });
Assert.Throws(typeof(FieldConvertError), delegate { IntConverter.Convert(""); });
Assert.Throws(typeof(FieldConvertError), delegate { IntConverter.Convert(null); });
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (null == value)
{
return(new CcBorder());
}
//从字符串解析
if (value is string stringValue)
{
if (stringValue.Length <= 0)
{
return(new CcBorder());
}
int size = 0, radius = 0;
CcCtrlPosition direction = CcCtrlPosition.None;
CcCtrlCorner corners = CcCtrlCorner.None;
stringValue.Split(Separator).ForEach(s =>
{
if (s.StartsWith(KeySize))
{
size = (int)IntConverter.ConvertFromString(context, culture, s.Substring(KeySize.Length));
}
else if (s.StartsWith(KeyDirection))
{
direction = (CcCtrlPosition)PositionConverter.ConvertFromString(context, culture, s.Substring(KeyDirection.Length));
}
else if (s.StartsWith(KeyRadius))
{
radius = (int)IntConverter.ConvertFromString(context, culture, s.Substring(KeyRadius.Length));
}
else if (s.StartsWith(KeyCorners))
{
corners = (CcCtrlCorner)CornerConverter.ConvertFromString(context, culture, s.Substring(KeyCorners.Length));
}
});
return(new CcBorder
{
Size = size,
OpenDirection = direction,
Radius = radius,
RadiusCorners = corners
});
}
return(base.ConvertFrom(context, culture, value));
}
public static void InitializeProcess()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.Title = "vm_host";
}
IntConverter.Register <char>();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.OutputEncoding = Encoding.Unicode;
}
}
public void IntConverter_CorrectConversionTest()
{
Array[] data = new int[][]
{
new int[] { int.MinValue, int.MaxValue },
new int[] { -30000, 60000 },
};
var converter = new IntConverter();
var sut = converter.Convert(data, 2, 2);
var expectation = new ushort[] { 0, ushort.MaxValue, 32767, 32768 };
sut.Should().BeEquivalentTo(expectation);
}
public void PositiveTestConvertToInt()
{
string num = "1514";
string num2 = "-1514";
int result = IntConverter.ConvertStringToInt(num);
int result2 = IntConverter.ConvertStringToInt(num2);
Assert.Multiple(() =>
{
Assert.AreEqual(1514, result);
Assert.AreEqual(-1514, result2);
});
}
public void ShouldFailToConvertToCSharpValue()
{
//Arrange
object value0;
object value1;
object value2;
var converter = new IntConverter();
//Act
bool success0 = converter.TryConvertToCSharpValue("9E10D", out value0);
bool success1 = converter.TryConvertToCSharpValue("N/A", out value1);
bool success2 = converter.TryConvertToCSharpValue("NaN", out value2);
//Assert
Assert.IsFalse(success0);
Assert.IsFalse(success1);
Assert.IsFalse(success2);
}
public void ShouldConvertToCellValue()
{
//Arrange
string value0;
string value1;
string value2;
var converter = new IntConverter();
//Act
bool success0 = converter.TryConvertToCellValue(123, out value0);
bool success1 = converter.TryConvertToCellValue(int.MaxValue, out value1);
bool success2 = converter.TryConvertToCellValue(-15, out value2);
//Assert
Assert.IsTrue(success0);
Assert.IsTrue(success1);
Assert.IsTrue(success2);
Assert.AreEqual("123", value0);
Assert.AreEqual(int.MaxValue.ToString(), value1);
Assert.AreEqual("-15", value2);
}
public void ShouldConvertToCSharpValue()
{
//Arrange
object value0;
object value1;
object value2;
var converter = new IntConverter();
//Act
bool success0 = converter.TryConvertToCSharpValue("123", out value0);
bool success1 = converter.TryConvertToCSharpValue("-1000", out value1);
bool success2 = converter.TryConvertToCSharpValue("0", out value2);
//Assert
Assert.IsTrue(success0);
Assert.IsTrue(success1);
Assert.IsTrue(success2);
Assert.AreEqual(123, value0);
Assert.AreEqual(-1000, value1);
Assert.AreEqual(0, value2);
}
public void GetStream1Test()
{
string lotId = "NCHFYRT";
List<ICassette> cassettes = PlcHelper.GetCassetteList(2);
LotCassetteInfoToStreamConverter_Accessor target = new LotCassetteInfoToStreamConverter_Accessor();
StringConverter stringConverter = new StringConverter();
IntConverter intConverter = new IntConverter();
string expected = stringConverter.ToStream(lotId).PadRight(28, '0');
expected += stringConverter.ToStream(cassettes[0].CassetteId.PadRight(8));
expected = expected.PadRight(44, '0');
expected += stringConverter.ToStream(cassettes[1].CassetteId.PadRight(8));
expected = expected.PadRight(60, '0');
expected = expected.PadRight(220, '0') + intConverter.ToStream(cassettes.Count);
Assert.AreEqual<string>(expected, target.GetStream(PlcHelper.GetLotData(lotId, cassettes, PlcHelper.GetWaferList(50, 2))));
}
public void GetStreamTest()
{
ILotData lotData = PlcHelper.GetLotData();
LotWaferInfoToStreamConverter_Accessor target = new LotWaferInfoToStreamConverter_Accessor();
IntConverter converter = new IntConverter();
string stream = converter.ToStream(lotData.Wafers.Count)
+ converter.ToStream(lotData.NGWaferCount)
+ "0008"
+ "0002"
+ "0001"
+ converter.ToStream(lotData.Assembly1.CarrierPlateCount)
+ converter.ToStream(lotData.Assembly1.WaferCount)
+ converter.ToStream(lotData.Assembly2.CarrierPlateCount)
+ converter.ToStream(lotData.Assembly2.WaferCount);
Assert.AreEqual<string>(stream, target.GetStream(lotData));
}
public void GetStream2Test()
{
string lotId = "NCHFYRT";
List<ICassette> cassettes = PlcHelper.GetCassetteList(12);
LotCassetteInfoToStreamConverter_Accessor target = new LotCassetteInfoToStreamConverter_Accessor();
StringConverter stringConverter = new StringConverter();
IntConverter intConverter = new IntConverter();
string expected = stringConverter.ToStream(lotId).PadRight(28, '0');
expected += stringConverter.ToStream(cassettes[0].CassetteId.PadRight(8));
expected = expected.PadRight(44, '0');
expected += stringConverter.ToStream(cassettes[1].CassetteId.PadRight(8));
expected = expected.PadRight(60, '0');
expected += stringConverter.ToStream(cassettes[2].CassetteId.PadRight(8));
expected = expected.PadRight(76, '0');
expected += stringConverter.ToStream(cassettes[3].CassetteId.PadRight(8));
expected = expected.PadRight(92, '0');
expected += stringConverter.ToStream(cassettes[4].CassetteId.PadRight(8));
expected = expected.PadRight(108, '0');
expected += stringConverter.ToStream(cassettes[5].CassetteId.PadRight(8));
expected = expected.PadRight(124, '0');
expected += stringConverter.ToStream(cassettes[6].CassetteId.PadRight(8));
expected = expected.PadRight(140, '0');
expected += stringConverter.ToStream(cassettes[7].CassetteId.PadRight(8));
expected = expected.PadRight(156, '0');
expected += stringConverter.ToStream(cassettes[8].CassetteId.PadRight(8));
expected = expected.PadRight(172, '0');
expected += stringConverter.ToStream(cassettes[9].CassetteId.PadRight(8));
expected = expected.PadRight(188, '0');
expected += stringConverter.ToStream(cassettes[10].CassetteId.PadRight(8));
expected = expected.PadRight(204, '0');
expected += stringConverter.ToStream(cassettes[11].CassetteId.PadRight(8));
expected = expected.PadRight(220, '0');
expected = expected.PadRight(220, '0') + intConverter.ToStream(cassettes.Count);
Assert.AreEqual<string>(expected, target.GetStream(PlcHelper.GetLotData(lotId, cassettes, PlcHelper.GetWaferList(300, 12))));
}
private static string MounterStatusStream3()
{
StringConverter stringConverter = new StringConverter();
IntConverter intConverter = new IntConverter();
string statusStream = "00FF" // station ID + pc ID
+ stringConverter.ToStream("LDPW8X2D") // cassette ID
+ "0001" // lot data request flag
+ "0001" // cassette ID error flag
+ "0000" // lot data communication timeout flag
+ stringConverter.ToStream("MZQPALJFIR2JCS") // new lot ID
+ "0001" // new lot start line
+ "0000" // new lot start flag
+ "0001" // carrier plate arrival flag
+ "0001" // BCR read OK flag
+ "0001" // carrier plate mounting ready flag
+ intConverter.ToStream(0) // wafer break information
+ "0001" // wafer break information OK flag
+ "0000" // mounting error carrier plate flag
+ "0000" // lot end flag
+ "0001" // reservation lot cancel flag
+ "22222222222222222222222222222222" // ... some data ...
+ "0004" // mounter machine state
+ "\u0003" // ETX
;
return statusStream;
}
public void IntConverter_ConvertBack()
{
IValueConverter converter;
object actualValue;
Type expectedType;
converter = new IntConverter();
expectedType = typeof(int);
//
// Test with null.
//
try
{
converter.ConvertBack(null);
Assert.Fail("Expected ArgumentNullException to be thrown.");
}
catch (ArgumentNullException)
{
}
//
// Test with incorrect value.
//
try
{
converter.ConvertBack("true");
Assert.Fail("Expected FormatException to be thrown.");
}
catch (FormatException)
{
}
try
{
converter.ConvertBack("999999999999999");
Assert.Fail("Expected OverflowException to be thrown.");
}
catch (OverflowException)
{
}
//
// Test with 0.
//
actualValue = converter.ConvertBack("0");
Assert.IsNotNull(actualValue, "Converted value is null.");
Assert.AreEqual(expectedType, actualValue.GetType(), "Type of converted value is incorrect.");
Assert.AreEqual(0, actualValue, "Converted value is incorrect.");
//
// Test with positive value.
//
actualValue = converter.ConvertBack("1024");
Assert.IsNotNull(actualValue, "Converted value is null.");
Assert.AreEqual(expectedType, actualValue.GetType(), "Type of converted value is incorrect.");
Assert.AreEqual(1024, actualValue, "Converted value is incorrect.");
//
// Test with negative value.
//
actualValue = converter.ConvertBack("-1024");
Assert.IsNotNull(actualValue, "Converted value is null.");
Assert.AreEqual(expectedType, actualValue.GetType(), "Type of converted value is incorrect.");
Assert.AreEqual(-1024, actualValue, "Converted value is incorrect.");
}
private static string MounterStatusStream2()
{
StringConverter stringConverter = new StringConverter();
IntConverter intConverter = new IntConverter();
string statusStream = "00FF" // station ID + pc ID
+ stringConverter.ToStream("IJKLMNOP") // cassette ID
+ "0000" // lot data request flag
+ "0001" // cassette ID error flag
+ "0001" // lot data communication timeout flag
+ stringConverter.ToStream("KCGE8PAQ1HC4HF") // new lot ID
+ "0002" // new lot start line
+ "0001" // new lot start flag
+ "0000" // carrier plate arrival flag
+ "0000" // BCR read OK flag
+ "0001" // carrier plate mounting ready flag
+ intConverter.ToStream(15) // wafer break information
+ "0001" // wafer break information OK flag
+ "0001" // mounting error carrier plate flag
+ "0001" // lot end flag
+ "0001" // reservation lot cancel flag
+ "11111111111111111111111111111111" // ... some data ...
+ "0003" // mounter machine state
+ "\u0003" // ETX
;
return statusStream;
}
public void ToStreamThrowsArgumentOutOfRangeException2Test()
{
IntConverter target = new IntConverter();
target.ToStream(10000);
}
public void ShouldFailToConvertToCellValue()
{
//Arrange
string value0;
string value1;
string value2;
var converter = new IntConverter();
//Act
bool success0 = converter.TryConvertToCellValue(0.18D, out value0);
bool success1 = converter.TryConvertToCellValue("-1", out value1);
bool success2 = converter.TryConvertToCellValue("NaN", out value2);
//Assert
Assert.IsFalse(success0);
Assert.IsFalse(success1);
Assert.IsFalse(success2);
}
public void GetStream4Test()
{
string lotId = "AA";
List<ICassette> cassettes = new List<ICassette>() { new Cassette() { CassetteId = "222" } };
LotCassetteInfoToStreamConverter_Accessor target = new LotCassetteInfoToStreamConverter_Accessor();
StringConverter stringConverter = new StringConverter();
IntConverter intConverter = new IntConverter();
string expected = stringConverter.ToStream(lotId).PadRight(28, '0');
expected += "3232322020202020";
expected = expected.PadRight(220, '0') + intConverter.ToStream(cassettes.Count);
Assert.AreEqual<string>(expected, target.GetStream(PlcHelper.GetLotData(lotId, cassettes, PlcHelper.GetWaferList(125, 5))));
}
public void IntConverter_Convert()
{
IValueConverter converter;
object actualValue;
Type expectedType;
converter = new IntConverter();
expectedType = typeof(string);
//
// Test with null.
//
try
{
converter.Convert(null);
Assert.Fail("Expected ArgumentNullException to be thrown.");
}
catch (ArgumentNullException)
{
}
//
// Test with incorrect type.
//
try
{
converter.Convert("true");
Assert.Fail("Expected ArgumentException to be thrown.");
}
catch (ArgumentException)
{
}
//
// Test with 0.
//
actualValue = converter.Convert(0);
Assert.IsNotNull(actualValue, "Converted value is null.");
Assert.AreEqual(expectedType, actualValue.GetType(), "Type of converted value is incorrect.");
Assert.AreEqual("0", actualValue, "Converted value is incorrect.");
//
// Test with negative value.
//
actualValue = converter.Convert(-1);
Assert.IsNotNull(actualValue, "Converted value is null.");
Assert.AreEqual(expectedType, actualValue.GetType(), "Type of converted value is incorrect.");
Assert.AreEqual("-1", actualValue, "Converted value is incorrect.");
//
// Test with positive value.
//
actualValue = converter.Convert(1024);
Assert.IsNotNull(actualValue, "Converted value is null.");
Assert.AreEqual(expectedType, actualValue.GetType(), "Type of converted value is incorrect.");
Assert.AreEqual("1024", actualValue, "Converted value is incorrect.");
}
public void WafersToStreamTest()
{
IList<IWafer> wafers = PlcHelper.GetWaferList(30, 2);
WafersToStreamConverter_Accessor target = new WafersToStreamConverter_Accessor();
IntConverter converter = new IntConverter();
string excepted = string.Empty;
foreach (IWafer wafer in wafers)
{
excepted += converter.ToStream(wafer.CassetteNumber) + converter.ToStream(wafer.SlotNumber);
}
Assert.AreEqual<string>(excepted, target.WafersToStream(wafers));
}
/**
* Matches a signature to the MsArg and if the signature matches unpacks the component values of a MsgArg into an object.
* This function resolved through variants, so if the MsgArg is a variant that references a 32 bit integer is can be unpacked
* directly into a 32 bit integer pointer.
*
* - @c 'a' An object containing an array
* - @c 'b' An object containing a bool
* - @c 'd' An object containing a double (64 bits)
* - @c 'g' An object containing a string that represents an AllJoyn signature
* - @c 'h' An object containing a Socket file desciptor
* - @c 'i' An object containing an int
* - @c 'n' An object containing a short
* - @c 'o' An object containing a string that represents the name of an AllJoyn object
* - @c 'q' An object containing a ushort
* - @c 's' An object containing a string
* - @c 't' An object containing a ulong
* - @c 'u' An object containing a uint
* - @c 'v' An object containing a MsgArg
* - @c 'x' An object containing a long
* - @c 'y' An object containing a byte
*
* - @c '(' and @c ')' An object containing a struct
* - @c '{' and @c '}' An object containing the key and value pair of a dictonary
*
* - @c '*' This matches any value type. This should not show up in a signature it is used by AllJoyn for matching
*
* @param sig The signature for MsgArg value
* @param[out] value object to hold the values unpacked from the MsgArg
* @return
* - QStatus.OK if the signature matched and MsgArg was successfully unpacked.
* - QStatus.BUS_SIGNATURE_MISMATCH if the signature did not match.
* - An error status otherwise
*/
//TODO add in examples into the Get documentation
public QStatus Get(string sig, out object value)
{
QStatus status = QStatus.OK;
value = null;
// handle multiple signatures in one get command
if (sig.Length > 1)
{
string[] sigs = splitSignature(sig);
if (sigs.Length > 1)
{
//is the signature larger than the passed in MsgArg?
if (sigs.Length > _length)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
object[] values = new object[sigs.Length];
for (int j = 0; j < sigs.Length; ++j)
{
status = this[j].Get(sigs[j], out values[j]);
if (AllJoyn.QStatus.OK != status)
{
return status;
}
}
value = values;
return status;
}
}
switch ((AllJoynTypeId)sig[0])
{
case AllJoynTypeId.ALLJOYN_BYTE:
byte y;
status = alljoyn_msgarg_get_uint8(_msgArg, out y);
value = y;
break;
case AllJoynTypeId.ALLJOYN_BOOLEAN:
bool b;
status = alljoyn_msgarg_get_bool(_msgArg, out b);
value = b;
break;
case AllJoynTypeId.ALLJOYN_INT16:
short n;
status = alljoyn_msgarg_get_int16(_msgArg, out n);
value = n;
break;
case AllJoynTypeId.ALLJOYN_UINT16:
ushort q;
status = alljoyn_msgarg_get_uint16(_msgArg, out q);
value = q;
break;
case AllJoynTypeId.ALLJOYN_INT32:
int i;
status = alljoyn_msgarg_get_int32(_msgArg, out i);
value = i;
break;
case AllJoynTypeId.ALLJOYN_UINT32:
uint u;
status = alljoyn_msgarg_get_uint32(_msgArg, out u);
value = u;
break;
case AllJoynTypeId.ALLJOYN_INT64:
long x;
status = alljoyn_msgarg_get_int64(_msgArg, out x);
value = x;
break;
case AllJoynTypeId.ALLJOYN_UINT64:
ulong t;
status = alljoyn_msgarg_get_uint64(_msgArg, out t);
value = t;
break;
case AllJoynTypeId.ALLJOYN_DOUBLE:
double d;
status = alljoyn_msgarg_get_double(_msgArg, out d);
value = d;
break;
case AllJoynTypeId.ALLJOYN_STRING:
IntPtr s;
status = alljoyn_msgarg_get_string(_msgArg, out s);
value = Marshal.PtrToStringAnsi(s);
break;
case AllJoynTypeId.ALLJOYN_OBJECT_PATH:
IntPtr o;
status = alljoyn_msgarg_get_objectpath(_msgArg, out o);
value = Marshal.PtrToStringAnsi(o);
break;
case AllJoynTypeId.ALLJOYN_SIGNATURE:
IntPtr g;
status = alljoyn_msgarg_get_signature(_msgArg, out g);
value = Marshal.PtrToStringAnsi(g);
break;
case AllJoynTypeId.ALLJOYN_VARIANT:
IntPtr v;
status = alljoyn_msgarg_get_variant(_msgArg, out v);
if (status)
{
value = new MsgArg(v);
}
break;
case AllJoynTypeId.ALLJOYN_ARRAY:
int length;
switch ((AllJoynTypeId)sig[1])
{
case AllJoynTypeId.ALLJOYN_BYTE:
IntPtr ay;
status = alljoyn_msgarg_get_uint8_array(_msgArg, out length, out ay);
byte[] ay_result = new byte[length];
Marshal.Copy(ay, ay_result, 0, length);
value = ay_result;
break;
case AllJoynTypeId.ALLJOYN_BOOLEAN:
IntPtr ab;
status = alljoyn_msgarg_get_bool_array(_msgArg, out length, out ab);
int[] ab_result = new int[length];
Marshal.Copy(ab, ab_result, 0, length);
bool[] ab_retValue = new bool[length];
for (int j = 0; j < length; j++)
{
if (ab_result[j] == 0)
{
ab_retValue[j] = false;
}
else
{
ab_retValue[j] = true;
}
}
value = ab_retValue;
break;
case AllJoynTypeId.ALLJOYN_INT16:
IntPtr an;
status = alljoyn_msgarg_get_int16_array(_msgArg, out length, out an);
short[] an_result = new short[length];
Marshal.Copy(an, an_result, 0, length);
value = an_result;
break;
case AllJoynTypeId.ALLJOYN_UINT16:
IntPtr aq;
status = alljoyn_msgarg_get_uint16_array(_msgArg, out length, out aq);
short[] aq_result = new short[length];
Marshal.Copy(aq, aq_result, 0, length);
ShortConverter shortConverter = new ShortConverter();
shortConverter.Shorts = aq_result;
value = shortConverter.UShorts;
break;
case AllJoynTypeId.ALLJOYN_INT32:
IntPtr ai;
status = alljoyn_msgarg_get_int32_array(_msgArg, out length, out ai);
int[] ai_result = new int[length];
Marshal.Copy(ai, ai_result, 0, length);
value = ai_result;
break;
case AllJoynTypeId.ALLJOYN_UINT32:
IntPtr au;
status = alljoyn_msgarg_get_uint32_array(_msgArg, out length, out au);
int[] au_result = new int[length];
Marshal.Copy(au, au_result, 0, length);
IntConverter intConverter = new IntConverter();
intConverter.Ints = au_result;
value = intConverter.UInts;
break;
case AllJoynTypeId.ALLJOYN_INT64:
IntPtr ax;
status = alljoyn_msgarg_get_int64_array(_msgArg, out length, out ax);
long[] ax_result = new long[length];
Marshal.Copy(ax, ax_result, 0, length);
value = ax_result;
break;
case AllJoynTypeId.ALLJOYN_UINT64:
IntPtr at;
status = alljoyn_msgarg_get_uint64_array(_msgArg, out length, out at);
long[] at_result = new long[length];
Marshal.Copy(at, at_result, 0, length);
LongConverter longConverter = new LongConverter();
longConverter.Longs = at_result;
value = longConverter.ULongs;
break;
case AllJoynTypeId.ALLJOYN_DOUBLE:
IntPtr ad;
status = alljoyn_msgarg_get_double_array(_msgArg, out length, out ad);
double[] ad_result = new double[length];
Marshal.Copy(ad, ad_result, 0, length);
value = ad_result;
break;
case AllJoynTypeId.ALLJOYN_STRING:
IntPtr sa;
status = alljoyn_msgarg_get_variant_array(_msgArg, "as", out length, out sa);
if (status)
{
string[] as_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_s;
status = alljoyn_msgarg_get_string(alljoyn_msgarg_array_element(sa, (UIntPtr)j), out inner_s);
as_result[j] = Marshal.PtrToStringAnsi(inner_s);
}
else
{
break;
}
}
value = as_result;
}
break;
case AllJoynTypeId.ALLJOYN_OBJECT_PATH:
IntPtr ao;
status = alljoyn_msgarg_get_variant_array(_msgArg, "ao", out length, out ao);
if (status)
{
string[] ao_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_o;
status = alljoyn_msgarg_get_objectpath(alljoyn_msgarg_array_element(ao, (UIntPtr)j), out inner_o);
ao_result[j] = Marshal.PtrToStringAnsi(inner_o);
}
else
{
break;
}
}
value = ao_result;
}
break;
case AllJoynTypeId.ALLJOYN_SIGNATURE:
IntPtr ag;
status = alljoyn_msgarg_get_variant_array(_msgArg, "ag", out length, out ag);
if (status)
{
string[] ag_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_g;
status = alljoyn_msgarg_get_signature(alljoyn_msgarg_array_element(ag, (UIntPtr)j), out inner_g);
ag_result[j] = Marshal.PtrToStringAnsi(inner_g);
}
else
{
break;
}
}
value = ag_result;
}
break;
case AllJoynTypeId.ALLJOYN_VARIANT:
IntPtr av;
status = alljoyn_msgarg_get_variant_array(_msgArg, "av", out length, out av);
if (status)
{
MsgArg av_result = new MsgArg(av);
av_result._length = length;
value = av_result;
}
break;
case AllJoynTypeId.ALLJOYN_DICT_ENTRY_OPEN:
int dict_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
System.Collections.Generic.Dictionary<object, object> dict = new System.Collections.Generic.Dictionary<object, object>();
// signature of form a{KV} where key is always one letter value
// just must be a complete signature lenght - 1 for K - 2 for 'a{' and '}'
string key_sig = sig.Substring(2, 1);
string value_sig = sig.Substring(3, sig.Length - 4);
if (key_sig == null || value_sig == null)
{
status = AllJoyn.QStatus.BUS_SIGNATURE_MISMATCH;
}
for (int j = 0; j < dict_size; ++j)
{
IntPtr inner_data_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out inner_data_ptr);
Object actualKey;
Object actualValue;
MsgArg key_MsgArg = new MsgArg(alljoyn_msgarg_getkey(inner_data_ptr));
MsgArg value_MsgArg = new MsgArg(alljoyn_msgarg_getvalue(inner_data_ptr));
key_MsgArg.Get(key_sig, out actualKey);
value_MsgArg.Get(value_sig, out actualValue);
dict.Add(actualKey, actualValue);
}
value = dict;
break;
case AllJoynTypeId.ALLJOYN_STRUCT_OPEN:
int struct_array_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
MsgArg struct_array = new MsgArg(struct_array_size);
for (int j = 0; j < struct_array_size; ++j)
{
IntPtr struct_array_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out struct_array_ptr);
AllJoyn.MsgArg tmp = new MsgArg(struct_array_ptr);
struct_array[j] = tmp;
}
value = struct_array;
break;
case AllJoynTypeId.ALLJOYN_ARRAY:
int outer_array_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
object[] outerArray = new object[outer_array_size];
for (int j = 0; j < outer_array_size; j++)
{
if (status)
{
IntPtr inner_data_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out inner_data_ptr);
MsgArg tmp = new MsgArg(inner_data_ptr);
string inner_array_sig = Marshal.PtrToStringAnsi(alljoyn_msgarg_get_array_elementsignature(_msgArg, (UIntPtr)j));
status = tmp.Get(inner_array_sig, out outerArray[j]);
}
else
{
break;
}
}
value = outerArray;
break;
default:
status = QStatus.WRITE_ERROR;
break;
}
break;
case AllJoynTypeId.ALLJOYN_STRUCT_OPEN:
if ((AllJoynTypeId)sig[sig.Length - 1] != AllJoynTypeId.ALLJOYN_STRUCT_CLOSE)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
string[] struct_sigs = splitSignature(sig.Substring(1, sig.Length - 2));
if (struct_sigs == null)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
int numMembers = alljoyn_msgarg_getnummembers(_msgArg);
if (numMembers != struct_sigs.Length)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
object[] structObjects = new object[numMembers];
for (int j = 0; j < struct_sigs.Length; ++j)
{
MsgArg arg = new MsgArg(alljoyn_msgarg_getmember(_msgArg, (UIntPtr)j));
status = arg.Get(struct_sigs[j], out structObjects[j]);
if (AllJoyn.QStatus.OK != status)
{
return status;
}
}
value = structObjects;
break;
case AllJoynTypeId.ALLJOYN_DICT_ENTRY_OPEN:
// A dictionary entry must start with 'a' followed by '{'
// if it starts with '{' it is an invalid signature.
status = QStatus.BUS_BAD_SIGNATURE;
break;
default:
status = QStatus.WRITE_ERROR;
break;
}
return status;
}
