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; }