Beispiel #1
0
        public void Left_Key_Stops_At_Start_And_Insert()
        {
            var field = new TextValidateField(new TextRegexProvider("^[0-9][0-9][0-9]$")
            {
                ValidateOnInput = false
            })
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            field.Text = "123";

            for (int i = 0; i < 10; i++)
            {
                field.ProcessKey(new KeyEvent(Key.CursorLeft, new KeyModifiers {
                }));
            }

            Assert.Equal("123", field.Text);
            Assert.True(field.IsValid);

            // Insert 4
            field.ProcessKey(new KeyEvent(Key.D4, new KeyModifiers {
            }));

            Assert.Equal("4123", field.Text);
            Assert.False(field.IsValid);
        }
Beispiel #2
0
        public void Input_Without_Validate_On_Input()
        {
            var field = new TextValidateField(new TextRegexProvider("^[0-9][0-9][0-9]$")
            {
                ValidateOnInput = false
            })
            {
                Width = 20
            };

            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));
            Assert.Equal("1", field.Text);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D2, new KeyModifiers {
            }));
            Assert.Equal("12", field.Text);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D3, new KeyModifiers {
            }));
            Assert.Equal("123", field.Text);
            Assert.True(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D4, new KeyModifiers {
            }));
            Assert.Equal("1234", field.Text);
            Assert.False(field.IsValid);
        }
Beispiel #3
0
        public void Insert_Skips_Non_Editable_Characters()
        {
            //                                                            ** **
            //                                                         01234567890
            var field = new TextValidateField(new NetMaskedTextProvider("--(00-00)--"))
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));
            Assert.Equal("--(1_-__)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D2, new KeyModifiers {
            }));
            Assert.Equal("--(12-__)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D3, new KeyModifiers {
            }));
            Assert.Equal("--(12-3_)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D4, new KeyModifiers {
            }));
            Assert.Equal("--(12-34)--", field.Provider.DisplayText);
            Assert.True(field.IsValid);
        }
Beispiel #4
0
        public void MouseClick_Right_X_Greater_Than_Text_Width_Goes_To_Last_Editable_Position()
        {
            //                                                            ****
            //                                                         0123456789
            var field = new TextValidateField(new NetMaskedTextProvider("--(0000)--"))
            {
                TextAlignment = TextAlignment.Left,
                Width         = 30
            };

            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));

            Assert.Equal("--(1___)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);

            field.MouseEvent(new MouseEvent()
            {
                X = 25, Flags = MouseFlags.Button1Pressed
            });

            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));

            Assert.Equal("--(1__1)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);
        }
Beispiel #5
0
        public void When_Valid_Is_Valid_True()
        {
            //                                                            ****
            //                                                         0123456789
            var field = new TextValidateField(new NetMaskedTextProvider("--(0000)--"))
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));
            Assert.Equal("--(1   )--", field.Text);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D2, new KeyModifiers {
            }));
            Assert.Equal("--(12  )--", field.Text);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D3, new KeyModifiers {
            }));
            Assert.Equal("--(123 )--", field.Text);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.D4, new KeyModifiers {
            }));
            Assert.Equal("--(1234)--", field.Text);
            Assert.True(field.IsValid);
        }
Beispiel #6
0
        public void End_Key_End_Of_Input()
        {
            // Exactly 5 numbers
            var field = new TextValidateField(new TextRegexProvider("^[0-9]{5}$")
            {
                ValidateOnInput = false
            })
            {
                Width = 20
            };

            for (int i = 0; i < 4; i++)
            {
                field.ProcessKey(new KeyEvent(Key.D0, new KeyModifiers {
                }));
            }

            Assert.Equal("0000", field.Text);
            Assert.False(field.IsValid);

            // HOME KEY
            field.ProcessKey(new KeyEvent(Key.Home, new KeyModifiers {
            }));

            // END KEY
            field.ProcessKey(new KeyEvent(Key.End, new KeyModifiers {
            }));

            // Insert 9
            field.ProcessKey(new KeyEvent(Key.D9, new KeyModifiers {
            }));

            Assert.Equal("00009", field.Text);
            Assert.True(field.IsValid);

            // Insert 9
            field.ProcessKey(new KeyEvent(Key.D9, new KeyModifiers {
            }));

            Assert.Equal("000099", field.Text);
            Assert.False(field.IsValid);
        }
Beispiel #7
0
        public void End_Key_Last_Editable_Character()
        {
            //                                                               *
            //                                                         0123456789
            var field = new TextValidateField(new NetMaskedTextProvider("--(0000)--"))
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            field.ProcessKey(new KeyEvent(Key.End, new KeyModifiers {
            }));

            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));

            Assert.Equal("--(___1)--", field.Provider.DisplayText);
            Assert.Equal("--(   1)--", field.Text);
            Assert.False(field.IsValid);
        }
Beispiel #8
0
        public void Home_Key_First_Editable_Character()
        {
            // Range 0 to 1000
            // Accepts 001 too.
            var field = new TextValidateField(new TextRegexProvider("^[0-9]?[0-9]?[0-9]|1000$"))
            {
                Width = 20
            };

            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));
            field.ProcessKey(new KeyEvent(Key.D0, new KeyModifiers {
            }));
            field.ProcessKey(new KeyEvent(Key.D0, new KeyModifiers {
            }));
            field.ProcessKey(new KeyEvent(Key.D0, new KeyModifiers {
            }));

            Assert.Equal("1000", field.Text);
            Assert.True(field.IsValid);

            // HOME KEY
            field.ProcessKey(new KeyEvent(Key.Home, new KeyModifiers {
            }));

            // DELETE
            field.ProcessKey(new KeyEvent(Key.Delete, new KeyModifiers {
            }));

            Assert.Equal("000", field.Text);
            Assert.True(field.IsValid);
        }
Beispiel #9
0
        public void Right_Key_Stops_In_Last_Editable_Character()
        {
            //                                                               *
            //                                                         0123456789
            var field = new TextValidateField(new NetMaskedTextProvider("--(0000)--"))
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            for (int i = 0; i < 10; i++)
            {
                field.ProcessKey(new KeyEvent(Key.CursorRight, new KeyModifiers {
                }));
            }
            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));

            Assert.Equal("--(___1)--", field.Provider.DisplayText);
            Assert.Equal("--(   1)--", field.Text);
            Assert.False(field.IsValid);
        }
Beispiel #10
0
        public void Backspace_Key_Deletes_Previous_Character()
        {
            //                                                            ****
            //                                                         0123456789
            var field = new TextValidateField(new NetMaskedTextProvider("--(0000)--")
            {
                Text = "1234"
            })
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            // Go to the end.
            field.ProcessKey(new KeyEvent(Key.End, new KeyModifiers {
            }));

            field.ProcessKey(new KeyEvent(Key.Backspace, new KeyModifiers {
            }));
            Assert.Equal("--(12_4)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.Backspace, new KeyModifiers {
            }));
            Assert.Equal("--(1__4)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.Backspace, new KeyModifiers {
            }));
            Assert.Equal("--(___4)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);

            // One more
            field.ProcessKey(new KeyEvent(Key.Backspace, new KeyModifiers {
            }));
            Assert.Equal("--(___4)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);
        }
Beispiel #11
0
        public void Initialized_With_Cursor_On_First_Editable_Character()
        {
            //                                                            *
            //                                                         0123456789
            var field = new TextValidateField(new NetMaskedTextProvider("--(0000)--"))
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));

            Assert.Equal("--(1___)--", field.Provider.DisplayText);
            Assert.Equal("--(1   )--", field.Text);
        }
Beispiel #12
0
        public void Input_Ilegal_Character()
        {
            //                                                            *
            //                                                         0123456789
            var field = new TextValidateField(new NetMaskedTextProvider("--(0000)--"))
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            field.ProcessKey(new KeyEvent(Key.A, new KeyModifiers {
            }));

            Assert.Equal("--(    )--", field.Text);
            Assert.Equal("--(____)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);
        }
Beispiel #13
0
        public void Delete_Key_Dosent_Move_Cursor()
        {
            //                                                            ****
            //                                                         0123456789
            var field = new TextValidateField(new NetMaskedTextProvider("--(0000)--")
            {
                Text = "1234"
            })
            {
                TextAlignment = TextAlignment.Centered,
                Width         = 20
            };

            Assert.Equal("--(1234)--", field.Provider.DisplayText);
            Assert.True(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.Delete, new KeyModifiers {
            }));
            field.ProcessKey(new KeyEvent(Key.Delete, new KeyModifiers {
            }));
            field.ProcessKey(new KeyEvent(Key.Delete, new KeyModifiers {
            }));

            Assert.Equal("--(_234)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);

            field.ProcessKey(new KeyEvent(Key.CursorRight, new KeyModifiers {
            }));
            field.ProcessKey(new KeyEvent(Key.CursorRight, new KeyModifiers {
            }));

            field.ProcessKey(new KeyEvent(Key.Delete, new KeyModifiers {
            }));
            field.ProcessKey(new KeyEvent(Key.Delete, new KeyModifiers {
            }));
            field.ProcessKey(new KeyEvent(Key.Delete, new KeyModifiers {
            }));

            Assert.Equal("--(_2_4)--", field.Provider.DisplayText);
            Assert.False(field.IsValid);
        }
Beispiel #14
0
        public void Input_With_Validate_On_Input_Set_Text()
        {
            var field = new TextValidateField(new TextRegexProvider("^[0-9][0-9][0-9]$"))
            {
                Width = 20
            };

            // Input dosen't validates the pattern.
            field.ProcessKey(new KeyEvent(Key.D1, new KeyModifiers {
            }));
            Assert.Equal("", field.Text);
            Assert.False(field.IsValid);

            // Dosen't match
            field.Text = "12356";
            Assert.Equal("", field.Text);
            Assert.False(field.IsValid);

            // Yes.
            field.Text = "123";
            Assert.Equal("123", field.Text);
            Assert.True(field.IsValid);
        }