Running batch model sequences it would be nice to be able to "Step Into", "Step Over" or "Step Out" for all testsockets with one click instead click instead the need to click on each testsocket before stepping into/over/out.
I have a sequence file that contains hundreds of sequences. It would be nice to be able to logically group and organize these sequences, such as in a tree control with virtual directories (hierarchy), instead of them being in a single long list.
Some test sequencing tools incorporate the idea of configuration based variant handling, where you could define different test variants (e.g. testing at ambient temperature, hot, cold), each variant having it's own set of test limits.
Individual test steps can then be assigned to the previously defined variants. By chossing the desired test variant, the according steps will be executed without having the need to implement additional logic within the sequence.
Now, when error happens (not during the execution but during the parsing) TS sequence editor displays message like below.
This message can be very meaningless and misleading as it doesn't indicate what is really wrong, it doesn't lead to any file.
It is very difficult to track, because it can happen that after switching the to the development mode this step can be perfectly fine.
Request: please do better description and explanation why particular VIs doesn't work with the RTE.
It's a very likley to happen that during the test the one LV module is called more than one time. As well it is very likely to happen the during the development we have to modify the module itself by changing the input/output from the VI or the connector pattern of the VI. If we have to Reload VI Prototype in one or two instances it's fine but when the step is in more than two or three places it is very painfull to update all of them.
So, I'm proposing to extend the Step Settings-->Module menu by adding the button with action Reload VI prototype in all instances.
Would be nice to have a possibility to skip execution of SequenceFileLoad callback by sequence editor configuration. It happened to me, that I've got 'dirty' programmed sequence files, which crashed sequence editor. Loading & debugging required additional work than.
When editing the Value text within Step Settings for a parameter, the Undo command completely reverts back to the state of the step prior to any entry modification. This is frustrating when a notable amount of code has been added/edited to an entry box and you want to "back up" a bit to a point somewhere between now and when you started editing. This functionality is already present in the expression browser: activating the Undo simply steps back into the process of the code you are writing. Can this functionality also be present in the Step Settings pane when entering code there? Once you press "Enter" to complete the entry, then the functionality could be as before (Undo reverts the entire edit). But when you're in the middle of typing code, Undo seems like it should just reverse the last steps of the code you are writing rather than completely abolish everything you've done during the edit.
Essentially, while actually editing the Value entry there should be a temporary Undo stack that is used for the text edits. This stack can be abolished and the main Undo Stack is resumed when the entry is submitted (press Enter, select a different field, etc.).
When you cancel the breakpoint set in the sequence file tab whilst this sequence file is running you can still see it in the execution view.
It's bit confusing, and needs correcting, I think.
As in the subject. Now when you would like to do new line by hitting the enter, whilst you are in the Expression Browser - > Expresion field (marked with yellow), the Expression browser gets closed.
It would be good for visibility if the new line creation would be allowed in this field.
I LOVE the autocomplete feature within any of the formula windows. Start typing Locals.F, and it allows you to autocomplete to Locals.Foo.
However, if you have Locals.Foo1, Locals.Foo2, Locals.Foo3, etc, you need to keep typing until you get enough to uniquely match the one you want, or start using the arrow keys in the list (or select with a mouse).
The problem is that if you just type Locals.F, the list of items that shows up is the entire list of Locals.*, in the order they are in Locals.* In reality, once I've typed Locals.F, I should only get the locals variables that start with F, so I don't need to down arrow through all the other Locals.Bar1, Locals.Bar2 that are inbetween Locals.Foo1 and Locals.Foo2 (because for some weird reason I really want the order of my locals variables to be Foo1, Bar1, Bar2, Foo2, Foo3).
So, let's restrict the autocomplete function to only show the items that match what I have already typed, or at least regroup the matching variables at the top of the list so they are easier to select from.
Even better would be to have it context aware. If the formula I am typing is "Locals.MyNumber = 3.1415 * Locals.F", and Locals.Foo1 is a string, Locals.Foo2 is an array of booleans, and Locals.Foo3 is a number, then it should skip over Locals.Foo1 and Foo2 because the context requires a number. Foo1, Foo2, Foo3 should all be in the list of items to choose from if I want to arrow up or down in the list (or use a mouse to select), but Foo3 should be the "defaulted" item that is used if I just hit enter after Locals.F.
As in subject,
It would be good to have the Fail execution option. When the step will fail the execution pointer shal be moved to clean-up part of the sequence (and parent sequences) and the whole execution will be marked as failed
Sometimes in the tests we would like to check are they any common elements for two arrays.
TS2013 have a nice function called Contains() using which devs can easly check if the searched element is in the array or not.
And what about the function which returns an array of common elements of two even more than two arrays?
Instaed of looping one array and issuing Contains() command it would be good to have a kind of logical AND using which we can have a list of common elements?
Would the operator overloading be the right things to do?
I propose to that the steps to have new feature called AllowableCallers.
Using this feature developers could restrict the callers (subsequences) from where the particular steps could be called.
Having this feature developers could prevent the mistakes of unintentional step copying during creating new subsequences using the copy-paste method.
The default value for this settings would be AllowAllCallers, but developer would be able to define the condition as they wish (function window f(x))
The best would be to draw/paint the feature I'm proposing. However, it would take not so small amount of time, so I decided, regrettably, to write about it.
I wrote the word regrettably because visualised description of the target feature would be very much more attractive than words. Anyway... Back to the point.
The description is as simple as in subject: to allow to change the colour of the background of each step (separately).
Could you imagine how much the readability of the sequence could be improved with this feature? I think that would improve it a lot.
Mainly this feature could be enabled during coding and debugging as during these activities the developers have the problem with readability especially when the sequence is long and the whole project is big and long in time. It could be set to off on when the sequence will be on the shop floor, nevertheless, even in the operator mode this feature could deliver some 'tracing' benefits.
Developers could easily group block of steps and in very natural way - just to color the background of the steps - create a visual
Reading colors is faster, easier, more intuitive than reading the structures (indent, nested calls). OK it is - let call it - one dimensional and it looks flat but it would add another degree of freedom in classifying/grouping the steps improving and speeding up overall readability.
The place (yellow) where this feature (just colour) can be controlled from:
As in the subject: add ability to sign the sequence with the digital signature.
It would be good in this feature will be able to access the certificates stored not only in Windows containers, as it is done in LV now, but the containers located on external carriers USB cards, card readers.
Exactly as in the subject.
Sometimes the names variables are long and could be deeply nested into containers.
Now it is difficult to use them as both windows: the main one and Selected are unresizable.
After proposed change the property loader would have all default features(behaviours) as you can expect from the window at this place.
Current situation presented on the picrure below.
For the moment, the precondition builder editor only allow to check steps status or to create custom conditions.
It would be nice to add a way to test the current sequence Status.
To handle this, i create my own custom condition by using the runtime variables Runstate.SequenceFailed and Runstate.SequenceError.
The problem is that these variables doesn't exist at edit time.
I think that adding this feature to the precondition builder editor could simplify our work.
The TestStand R&D team is committed to reviewing every idea submitted via the TestStand Idea Exchange. However, we cannot guarantee the implementation of any TestStand Idea Exchange submission until further documented.