langtools/test/jdk/jshell/ToolCommandOptionTest.java
changeset 41635 cb3d04878117
parent 41514 a75c2b869d8d
child 41641 a628785b9dd9
equal deleted inserted replaced
41634:3f9c491b05aa 41635:cb3d04878117
    21  * questions.
    21  * questions.
    22  */
    22  */
    23 
    23 
    24  /*
    24  /*
    25  * @test
    25  * @test
    26  * @bug 8157395 8157393 8157517 8158738  8167128
    26  * @bug 8157395 8157393 8157517 8158738 8167128 8163840
    27  * @summary Tests of jshell comand options, and undoing operations
    27  * @summary Tests of jshell comand options, and undoing operations
    28  * @modules jdk.jshell/jdk.internal.jshell.tool
    28  * @modules jdk.jshell/jdk.internal.jshell.tool
    29  * @build ToolCommandOptionTest ReplToolTesting
    29  * @build ToolCommandOptionTest ReplToolTesting
    30  * @run testng ToolCommandOptionTest
    30  * @run testng ToolCommandOptionTest
    31  */
    31  */
   126                 (a) -> assertCommand(a, "/set editor -default prog",
   126                 (a) -> assertCommand(a, "/set editor -default prog",
   127                         "|  Specify -default option or program, not both -- /set editor -default prog"),
   127                         "|  Specify -default option or program, not both -- /set editor -default prog"),
   128                 (a) -> assertCommand(a, "/set editor prog",
   128                 (a) -> assertCommand(a, "/set editor prog",
   129                         "|  Editor set to: prog"),
   129                         "|  Editor set to: prog"),
   130                 (a) -> assertCommand(a, "/set editor prog -default",
   130                 (a) -> assertCommand(a, "/set editor prog -default",
   131                         "|  Editor set to: prog"),
   131                         "|  Editor set to: prog -default"),
       
   132                 (a) -> assertCommand(a, "/set editor",
       
   133                         "|  /set editor prog -default"),
   132                 (a) -> assertCommand(a, "/se ed prog -furball",
   134                 (a) -> assertCommand(a, "/se ed prog -furball",
   133                         "|  Editor set to: prog"),
   135                         "|  Editor set to: prog -furball"),
       
   136                 (a) -> assertCommand(a, "/set editor",
       
   137                         "|  /set editor prog -furball"),
   134                 (a) -> assertCommand(a, "/set editor prog arg1 -furball arg3 -default arg4",
   138                 (a) -> assertCommand(a, "/set editor prog arg1 -furball arg3 -default arg4",
   135                         "|  Editor set to: prog"),
   139                         "|  Editor set to: prog arg1 -furball arg3 -default arg4"),
       
   140                 (a) -> assertCommand(a, "/set editor",
       
   141                         "|  /set editor prog arg1 -furball arg3 -default arg4"),
   136                 (a) -> assertCommand(a, "/set editor -default",
   142                 (a) -> assertCommand(a, "/set editor -default",
   137                         ""),
   143                         "|  Editor set to: -default"),
   138                 (a) -> assertCommand(a, "/se edi -def",
   144                 (a) -> assertCommand(a, "/se edi -def",
   139                         ""),
   145                         "|  Editor set to: -default"),
   140                 (a) -> assertCommand(a, "/set editor",
   146                 (a) -> assertCommand(a, "/set editor",
   141                         "|  The '/set editor' command requires a path argument")
   147                         "|  /set editor -default")
   142         );
   148         );
   143     }
   149     }
   144 
   150 
   145     public void retainEditorTest() {
   151     public void retainEditorTest() {
   146         test(
   152         test(
   147                 (a) -> assertCommand(a, "/retain editor -furball",
   153                 (a) -> assertCommand(a, "/set editor -retain -furball",
   148                         "|  Unknown option: -furball -- /retain editor -furball"),
   154                         "|  Unknown option: -furball -- /set editor -retain -furball"),
   149                 (a) -> assertCommand(a, "/retain editor -furball prog",
   155                 (a) -> assertCommand(a, "/set editor -retain -furball prog",
   150                         "|  Unknown option: -furball -- /retain editor -furball prog"),
   156                         "|  Unknown option: -furball -- /set editor -retain -furball prog"),
   151                 (a) -> assertCommand(a, "/retain editor -furball -mattress",
   157                 (a) -> assertCommand(a, "/set editor -retain -furball -mattress",
   152                         "|  Unknown option: -furball -mattress -- /retain editor -furball -mattress"),
   158                         "|  Unknown option: -furball -mattress -- /set editor -retain -furball -mattress"),
   153                 (a) -> assertCommand(a, "/retain editor -default prog",
   159                 (a) -> assertCommand(a, "/set editor -retain -default prog",
   154                         "|  Specify -default option or program, not both -- /retain editor -default prog"),
   160                         "|  Specify -default option or program, not both -- /set editor -retain -default prog"),
   155                 (a) -> assertCommand(a, "/retain editor -default -wait",
   161                 (a) -> assertCommand(a, "/set editor -retain -wait",
   156                         "|  -wait applies to external editors, cannot be used with -default"),
   162                         "|  -wait applies to external editors"),
   157                 (a) -> assertCommand(a, "/retain editor prog",
   163                 (a) -> assertCommand(a, "/set editor -retain -default -wait",
   158                         "|  Editor set to: prog"),
   164                         "|  -wait applies to external editors"),
   159                 (a) -> assertCommand(a, "/retain editor prog -default",
   165                 (a) -> assertCommand(a, "/set editor -retain prog",
   160                         "|  Editor set to: prog"),
   166                         "|  Editor set to: prog\n" +
   161                 (a) -> assertCommand(a, "/ret ed prog -furball",
   167                         "|  Editor setting retained: prog"),
   162                         "|  Editor set to: prog"),
   168                 (a) -> assertCommand(a, "/set editor",
   163                 (a) -> assertCommand(a, "/retain editor prog arg1 -furball arg3 -default arg4",
   169                         "|  /set editor -retain prog"),
   164                         "|  Editor set to: prog"),
   170                 (a) -> assertCommand(a, "/se ed other",
   165                 (a) -> assertCommand(a, "/retain editor -default",
   171                         "|  Editor set to: other"),
   166                         ""),
   172                 (a) -> assertCommand(a, "/set editor",
   167                 (a) -> assertCommand(a, "/reta edi -def",
   173                         "|  /set editor -retain prog\n" +
   168                         ""),
   174                         "|  /set editor other"),
   169                 (a) -> assertCommand(a, "/retain editor",
   175                 (a) -> assertCommand(a, "/set editor -retain prog -default",
   170                         "")
   176                         "|  Editor set to: prog -default\n" +
       
   177                         "|  Editor setting retained: prog -default"),
       
   178                 (a) -> assertCommand(a, "/set editor",
       
   179                         "|  /set editor -retain prog -default"),
       
   180                 (a) -> assertCommand(a, "/se ed -retain prog -furball",
       
   181                         "|  Editor set to: prog -furball\n" +
       
   182                         "|  Editor setting retained: prog -furball"),
       
   183                 (a) -> assertCommand(a, "/set editor -retain prog arg1 -furball arg3 -default arg4",
       
   184                         "|  Editor set to: prog arg1 -furball arg3 -default arg4\n" +
       
   185                         "|  Editor setting retained: prog arg1 -furball arg3 -default arg4"),
       
   186                 (a) -> assertCommand(a, "/set editor",
       
   187                         "|  /set editor -retain prog arg1 -furball arg3 -default arg4"),
       
   188                 (a) -> assertCommand(a, "/set editor -retain -default",
       
   189                         "|  Editor set to: -default\n" +
       
   190                         "|  Editor setting retained: -default"),
       
   191                 (a) -> assertCommand(a, "/set editor",
       
   192                         "|  /set editor -retain -default"),
       
   193                 (a) -> assertCommand(a, "/se e -ret -def",
       
   194                         "|  Editor set to: -default\n" +
       
   195                         "|  Editor setting retained: -default"),
       
   196                 (a) -> assertCommand(a, "/set editor -retain",
       
   197                         "|  Editor setting retained: -default")
   171         );
   198         );
   172     }
   199     }
   173 
   200 
   174     public void setStartTest() {
   201     public void setStartTest() {
   175         test(
   202         test(
   180                 (a) -> assertCommand(a, "/se st pyle -furball",
   207                 (a) -> assertCommand(a, "/se st pyle -furball",
   181                         "|  Unknown option: -furball -- /set st pyle -furball"),
   208                         "|  Unknown option: -furball -- /set st pyle -furball"),
   182                 (a) -> assertCommand(a, "/set start -furball -mattress",
   209                 (a) -> assertCommand(a, "/set start -furball -mattress",
   183                         "|  Unknown option: -furball -mattress -- /set start -furball -mattress"),
   210                         "|  Unknown option: -furball -mattress -- /set start -furball -mattress"),
   184                 (a) -> assertCommand(a, "/set start foo -default",
   211                 (a) -> assertCommand(a, "/set start foo -default",
   185                         "|  Specify either one option or a startup file name -- /set start foo -default"),
   212                         "|  Specify no more than one of -default, -none, or a startup file name -- /set start foo -default"),
   186                 (a) -> assertCommand(a, "/set start frfg",
   213                 (a) -> assertCommand(a, "/set start frfg",
   187                         "|  File 'frfg' for '/set start' is not found."),
   214                         "|  File 'frfg' for '/set start' is not found."),
   188                 (a) -> assertCommand(a, "/set start -default",
   215                 (a) -> assertCommand(a, "/set start -default",
   189                         ""),
   216                         ""),
       
   217                 (a) -> assertCommand(a, "/set start",
       
   218                         "|  /set start -default"),
   190                 (a) -> assertCommand(a, "/se sta -no",
   219                 (a) -> assertCommand(a, "/se sta -no",
   191                         ""),
   220                         ""),
   192                 (a) -> assertCommand(a, "/set start",
   221                 (a) -> assertCommand(a, "/set start",
   193                         "|  Specify either one option or a startup file name -- /set start")
   222                         "|  /set start -none")
   194         );
   223         );
   195     }
   224     }
   196 
   225 
   197     public void retainStartTest() {
   226     public void retainStartTest() {
   198         test(
   227         test(
   199                 (a) -> assertCommand(a, "/retain start -furball",
   228                 (a) -> assertCommand(a, "/set start -retain -furball",
   200                         "|  Unknown option: -furball -- /retain start -furball"),
   229                         "|  Unknown option: -furball -- /set start -retain -furball"),
   201                 (a) -> assertCommand(a, "/retain start -furball pyle",
   230                 (a) -> assertCommand(a, "/set start -retain -furball pyle",
   202                         "|  Unknown option: -furball -- /retain start -furball pyle"),
   231                         "|  Unknown option: -furball -- /set start -retain -furball pyle"),
   203                 (a) -> assertCommand(a, "/ret st pyle -furball",
   232                 (a) -> assertCommand(a, "/se st -re pyle -furball",
   204                         "|  Unknown option: -furball -- /retain st pyle -furball"),
   233                         "|  Unknown option: -furball -- /set st -re pyle -furball"),
   205                 (a) -> assertCommand(a, "/retain start -furball -mattress",
   234                 (a) -> assertCommand(a, "/set start -retain -furball -mattress",
   206                         "|  Unknown option: -furball -mattress -- /retain start -furball -mattress"),
   235                         "|  Unknown option: -furball -mattress -- /set start -retain -furball -mattress"),
   207                 (a) -> assertCommand(a, "/retain start foo -default",
   236                 (a) -> assertCommand(a, "/set start -retain foo -default",
   208                         "|  Specify either one option or a startup file name -- /retain start foo -default"),
   237                         "|  Specify no more than one of -default, -none, or a startup file name -- /set start -retain foo -default"),
   209                 (a) -> assertCommand(a, "/retain start frfg",
   238                 (a) -> assertCommand(a, "/set start -retain -default foo",
   210                         "|  File 'frfg' for '/retain start' is not found."),
   239                         "|  Specify no more than one of -default, -none, or a startup file name -- /set start -retain -default foo"),
   211                 (a) -> assertCommand(a, "/retain start -default",
   240                 (a) -> assertCommand(a, "/set start -retain frfg",
   212                         ""),
   241                         "|  File 'frfg' for '/set start' is not found."),
   213                 (a) -> assertCommand(a, "/ret sta -no",
   242                 (a) -> assertCommand(a, "/set start -retain -default",
   214                         ""),
   243                         ""),
   215                 (a) -> assertCommand(a, "/retain start",
   244                 (a) -> assertCommand(a, "/set start",
   216                         "")
   245                         "|  /set start -retain -default"),
       
   246                 (a) -> assertCommand(a, "/set sta -no",
       
   247                         ""),
       
   248                 (a) -> assertCommand(a, "/set start",
       
   249                         "|  /set start -retain -default\n" +
       
   250                         "|  /set start -none"),
       
   251                 (a) -> assertCommand(a, "/se st -ret",
       
   252                         ""),
       
   253                 (a) -> assertCommand(a, "/se sta",
       
   254                         "|  /set start -retain -none")
   217         );
   255         );
   218     }
   256     }
   219 
   257 
   220     public void setModeTest() {
   258     public void setModeTest() {
   221         test(
   259         test(
   222                 (a) -> assertCommandOutputStartsWith(a, "/set mode",
   260                 (a) -> assertCommandOutputContains(a, "/set mode",
   223                         "|  Missing the feedback mode"),
   261                         "|  /set format verbose unresolved"),
   224                 (a) -> assertCommandOutputStartsWith(a, "/set mode *",
   262                 (a) -> assertCommandOutputStartsWith(a, "/set mode *",
   225                         "|  Expected a feedback mode name: *"),
   263                         "|  Expected a feedback mode name: *"),
   226                 (a) -> assertCommandOutputStartsWith(a, "/set mode -quiet",
   264                 (a) -> assertCommandOutputStartsWith(a, "/set mode -quiet",
   227                         "|  Missing the feedback mode"),
   265                         "|  Missing the feedback mode"),
   228                 (a) -> assertCommandOutputStartsWith(a, "/set mode -quiet *",
   266                 (a) -> assertCommandOutputStartsWith(a, "/set mode -quiet *",
   229                         "|  Expected a feedback mode name: *"),
   267                         "|  Expected a feedback mode name: *"),
   230                 (a) -> assertCommandOutputStartsWith(a, "/set mode amode normal thing",
   268                 (a) -> assertCommandOutputStartsWith(a, "/set mode amode normal thing",
   231                         "|  Unexpected arguments at end of command: thing"),
   269                         "|  Unexpected arguments at end of command: thing"),
   232                 (a) -> assertCommand(a, "/set mode mymode",
   270                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode",
       
   271                         "|  To create a new mode either the -command or the -quiet option must be used"),
       
   272                 (a) -> assertCommand(a, "/set mode mymode -command",
   233                         "|  Created new feedback mode: mymode"),
   273                         "|  Created new feedback mode: mymode"),
   234                 (a) -> assertCommand(a, "/set mode mymode -delete",
   274                 (a) -> assertCommand(a, "/set mode mymode -delete",
   235                         ""),
   275                         ""),
   236                 (a) -> assertCommand(a, "/set mode mymode normal",
   276                 (a) -> assertCommand(a, "/set mode mymode normal -command",
   237                         "|  Created new feedback mode: mymode"),
   277                         "|  Created new feedback mode: mymode"),
   238                 (a) -> assertCommand(a, "/set mode -del mymode",
   278                 (a) -> assertCommand(a, "/set mode -del mymode",
   239                         ""),
   279                         ""),
   240                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -command -quiet",
   280                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -command -quiet",
   241                         "|  Conflicting options"),
   281                         "|  Conflicting options"),
   243                         "|  Conflicting options"),
   283                         "|  Conflicting options"),
   244                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -command -delete",
   284                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -command -delete",
   245                         "|  Conflicting options"),
   285                         "|  Conflicting options"),
   246                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -d",
   286                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -d",
   247                         "|  No feedback mode named: mymode"),
   287                         "|  No feedback mode named: mymode"),
   248                 (a) -> assertCommandOutputStartsWith(a, "/set mode normal",
   288                 (a) -> assertCommandOutputStartsWith(a, "/set mode normal -c",
   249                         "|  Not valid with a predefined mode: normal"),
   289                         "|  Mode to be created already exists: normal"),
   250                 (a) -> assertCommand(a, "/se mo -c mymode",
   290                 (a) -> assertCommand(a, "/se mo -c mymode",
   251                         "|  Created new feedback mode: mymode"),
   291                         "|  Created new feedback mode: mymode"),
       
   292                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode",
       
   293                         "|  /set mode mymode -command"),
   252                 (a) -> assertCommand(a, "/set feedback mymode",
   294                 (a) -> assertCommand(a, "/set feedback mymode",
   253                         "|  Feedback mode: mymode"),
   295                         "|  Feedback mode: mymode"),
       
   296                 (a) -> assertCommand(a, "/se fe",
       
   297                         "|  /set feedback mymode\n" +
       
   298                         "|  \n" +
       
   299                         "|  Available feedback modes:\n" +
       
   300                         "|     concise\n" +
       
   301                         "|     mymode\n" +
       
   302                         "|     normal\n" +
       
   303                         "|     silent\n" +
       
   304                         "|     verbose"),
   254                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -delete",
   305                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -delete",
   255                         "|  The current feedback mode 'mymode' cannot be deleted"),
   306                         "|  The current feedback mode 'mymode' cannot be deleted"),
   256                 (a) -> assertCommand(a, "/set feedback no",
   307                 (a) -> assertCommand(a, "/set feedback no",
   257                         "|  Feedback mode: normal"),
   308                         "|  Feedback mode: normal"),
   258                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -delete",
   309                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -delete",
   259                         ""),
   310                         ""),
       
   311                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode",
       
   312                         "|  To create a new mode either the -command or the -quiet option must be used -- \n" +
       
   313                         "|  Does not match any current feedback mode: mymode -- /set mode mymode\n" +
       
   314                         "|  Available feedback modes:"),
   260                 (a) -> assertCommandCheckOutput(a, "/set feedback",
   315                 (a) -> assertCommandCheckOutput(a, "/set feedback",
   261                         (s) -> assertFalse(s.contains("mymode"), "Didn't delete: " + s))
   316                         (s) -> assertFalse(s.contains("mymode"), "Didn't delete: " + s))
   262         );
   317         );
   263     }
   318     }
   264 
   319 
   270                         "|  Feedback mode: mymode"),
   325                         "|  Feedback mode: mymode"),
   271                 (a) -> assertCommand(a, "/set format mymode display 'blurb'",
   326                 (a) -> assertCommand(a, "/set format mymode display 'blurb'",
   272                         ""),
   327                         ""),
   273                 (a) -> assertCommand(a, "45",
   328                 (a) -> assertCommand(a, "45",
   274                         "blurb"),
   329                         "blurb"),
   275                 (a) -> assertCommand(a, "/set mode mymode normal",
   330                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode normal",
   276                         "|  Created new feedback mode: mymode"),
   331                         "|  To create a new mode either the -command or the -quiet option must be used"),
       
   332                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -command normal",
       
   333                         "|  Mode to be created already exists: mymode"),
       
   334                 (a) -> assertCommandOutputStartsWith(a, "/set mode mymode -delete",
       
   335                         "|  The current feedback mode 'mymode' cannot be deleted, use '/set feedback' first"),
       
   336                 (a) -> assertCommand(a, "/set feedback normal",
       
   337                         "|  Feedback mode: normal"),
       
   338                 (a) -> assertCommand(a, "/set mode mymode -delete",
       
   339                         ""),
       
   340                 (a) -> assertCommand(a, "/set mode mymode -command normal",
       
   341                         "|  Created new feedback mode: mymode"),
       
   342                 (a) -> assertCommand(a, "/set feedback mymode",
       
   343                         "|  Feedback mode: mymode"),
   277                 (a) -> assertCommandOutputContains(a, "45",
   344                 (a) -> assertCommandOutputContains(a, "45",
   278                         " ==> 45")
   345                         " ==> 45")
   279         );
   346         );
   280     }
   347     }
   281 
   348 
   282     public void retainModeTest() {
   349     public void retainModeTest() {
   283         test(
   350         test(
   284                 (a) -> assertCommandOutputStartsWith(a, "/retain mode",
   351                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain",
   285                         "|  Missing the feedback mode"),
   352                         "|  Missing the feedback mode"),
   286                 (a) -> assertCommandOutputStartsWith(a, "/retain mode *",
   353                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain *",
   287                         "|  Expected a feedback mode name: *"),
   354                         "|  Expected a feedback mode name: *"),
   288                 (a) -> assertCommandOutputStartsWith(a, "/retain mode amode normal",
   355                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain amode normal",
   289                         "|  Unexpected arguments at end of command: normal"),
   356                         "|  Unexpected arguments at end of command: normal"),
   290                 (a) -> assertCommandOutputStartsWith(a, "/retain mode mymode",
   357                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain mymode",
   291                         "|  Does not match any current feedback mode: mymode"),
       
   292                 (a) -> assertCommandOutputStartsWith(a, "/retain mode mymode -delete",
       
   293                         "|  No feedback mode named: mymode"),
   358                         "|  No feedback mode named: mymode"),
   294                 (a) -> assertCommandOutputStartsWith(a, "/retain mode -d mymode",
   359                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain mymode -delete",
   295                         "|  No feedback mode named: mymode"),
   360                         "|  No feedback mode named: mymode"),
   296                 (a) -> assertCommandOutputStartsWith(a, "/retain mode normal",
   361                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain -d mymode",
       
   362                         "|  No feedback mode named: mymode"),
       
   363                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain normal",
   297                         "|  Not valid with a predefined mode: normal"),
   364                         "|  Not valid with a predefined mode: normal"),
   298                 (a) -> assertCommand(a, "/set mode mymode verbose",
   365                 (a) -> assertCommand(a, "/set mode mymode verbose -command",
   299                         "|  Created new feedback mode: mymode"),
   366                         "|  Created new feedback mode: mymode"),
   300                 (a) -> assertCommand(a, "/retain mode mymode",
   367                 (a) -> assertCommand(a, "/set mode -retain mymode",
   301                         ""),
   368                         ""),
   302                 (a) -> assertCommand(a, "/set mode mymode -delete",
   369                 (a) -> assertCommand(a, "/set mode mymode -delete",
   303                         ""),
   370                         ""),
   304                 (a) -> assertCommand(a, "/retain mode mymode -delete",
   371                 (a) -> assertCommand(a, "/set mode -retain mymode -delete",
   305                         ""),
   372                         ""),
   306                 (a) -> assertCommand(a, "/set mode kmode normal",
   373                 (a) -> assertCommand(a, "/set mode kmode normal -command",
   307                         "|  Created new feedback mode: kmode"),
   374                         "|  Created new feedback mode: kmode"),
   308                 (a) -> assertCommand(a, "/retain mode kmode",
   375                 (a) -> assertCommand(a, "/set mode -retain kmode",
   309                         ""),
   376                         ""),
   310                 (a) -> assertCommand(a, "/set mode kmode -delete",
   377                 (a) -> assertCommand(a, "/set mode kmode -delete",
   311                         ""),
   378                         ""),
   312                 (a) -> assertCommand(a, "/set mode tmode normal",
   379                 (a) -> assertCommand(a, "/set mode tmode normal -command",
   313                         "|  Created new feedback mode: tmode"),
   380                         "|  Created new feedback mode: tmode"),
   314                 (a) -> assertCommandOutputStartsWith(a, "/retain feedback tmode",
   381                 (a) -> assertCommandOutputStartsWith(a, "/set feedback -retain tmode",
   315                         "|  '/retain feedback <mode>' requires that <mode> is predefined or has been retained with '/retain mode'"),
   382                         "|  '/set feedback -retain <mode>' requires that <mode> is predefined or has been retained with '/set mode -retain'"),
   316                 (a) -> assertCommand(a, "/set format tmode display 'YES'",
   383                 (a) -> assertCommand(a, "/set format tmode display 'YES'",
   317                         ""),
   384                         ""),
   318                 (a) -> assertCommand(a, "/set feedback tmode",
   385                 (a) -> assertCommand(a, "/set feedback tmode",
   319                         "|  Feedback mode: tmode"),
   386                         "|  Feedback mode: tmode"),
   320                 (a) -> assertCommand(a, "45",
   387                 (a) -> assertCommand(a, "45",
   321                         "YES"),
   388                         "YES"),
   322                 (a) -> assertCommand(a, "/retain mode tmode",
   389                 (a) -> assertCommand(a, "/set mode -retain tmode",
   323                         ""),
   390                         ""),
   324                 (a) -> assertCommand(a, "/retain feedback tmode",
   391                 (a) -> assertCommand(a, "/set feedback -retain tmode",
   325                         "|  Feedback mode: tmode"),
   392                         "|  Feedback mode: tmode"),
   326                 (a) -> assertCommand(a, "/set format tmode display 'blurb'",
   393                 (a) -> assertCommand(a, "/set format tmode display 'blurb'",
   327                         ""),
   394                         ""),
       
   395                 (a) -> assertCommand(a, "/set format tmode display",
       
   396                         "|  /set format tmode display \"blurb\""),
       
   397                 (a) -> assertCommandOutputContains(a, "/set mode tmode",
       
   398                         "|  /set format tmode display \"YES\""),
   328                 (a) -> assertCommand(a, "45",
   399                 (a) -> assertCommand(a, "45",
   329                         "blurb")
   400                         "blurb")
   330         );
   401         );
   331         test(
   402         test(
       
   403                 (a) -> assertCommand(a, "/set format tmode display",
       
   404                         "|  /set format tmode display \"YES\""),
       
   405                 (a) -> assertCommandOutputContains(a, "/set mode tmode",
       
   406                         "|  /set format tmode display \"YES\""),
   332                 (a) -> assertCommand(a, "45",
   407                 (a) -> assertCommand(a, "45",
   333                         "YES"),
   408                         "YES"),
   334                 (a) -> assertCommand(a, "/set feedback kmode",
   409                 (a) -> assertCommand(a, "/set feedback kmode",
   335                         "|  Feedback mode: kmode"),
   410                         "|  Feedback mode: kmode"),
   336                 (a) -> assertCommandOutputStartsWith(a, "/retain mode kmode -delete",
   411                 (a) -> assertCommand(a, "/set feedback",
       
   412                         "|  /set feedback -retain tmode\n" +
       
   413                         "|  /set feedback kmode\n" +
       
   414                         "|  \n" +
       
   415                         "|  Retained feedback modes:\n" +
       
   416                         "|     kmode\n" +
       
   417                         "|     tmode\n" +
       
   418                         "|  Available feedback modes:\n" +
       
   419                         "|     concise\n" +
       
   420                         "|     kmode\n" +
       
   421                         "|     normal\n" +
       
   422                         "|     silent\n" +
       
   423                         "|     tmode\n" +
       
   424                         "|     verbose"),
       
   425                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain kmode -delete",
   337                         "|  The current feedback mode 'kmode' cannot be deleted"),
   426                         "|  The current feedback mode 'kmode' cannot be deleted"),
   338                 (a) -> assertCommandOutputStartsWith(a, "/retain mode tmode -delete",
   427                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain tmode -delete",
   339                         "|  The retained feedback mode 'tmode' cannot be deleted"),
   428                         "|  The retained feedback mode 'tmode' cannot be deleted"),
   340                 (a) -> assertCommand(a, "/retain feedback normal",
   429                 (a) -> assertCommand(a, "/set feedback -retain normal",
   341                         "|  Feedback mode: normal"),
   430                         "|  Feedback mode: normal"),
   342                 (a) -> assertCommand(a, "/retain mode tmode -delete",
   431                 (a) -> assertCommand(a, "/set mode -retain tmode -delete",
   343                         ""),
   432                         ""),
   344                 (a) -> assertCommandOutputStartsWith(a, "/retain mode kmode -delete",
   433                 (a) -> assertCommandOutputStartsWith(a, "/set mode -retain kmode -delete",
   345                         "")
   434                         "")
   346         );
   435         );
   347         test(
   436         test(
   348                 (a) -> assertCommandOutputStartsWith(a, "/set feedback tmode",
   437                 (a) -> assertCommandOutputStartsWith(a, "/set feedback tmode",
   349                         "|  Does not match any current feedback mode: tmode"),
   438                         "|  Does not match any current feedback mode: tmode"),