tree 682bde6af97d79a1e63dc18610f5328596117d2d
parent 8ad0bdfe3f2ff2a45e00981b736059bb7aabd603
author Andrei Litvin <andy314@gmail.com> 1721853035 -0400
committer GitHub <noreply@github.com> 1721853035 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJmoWRrCRC1aQ7uu5UhlAAA5lUQAGFdHEghTsWgfbFBPKYNrMT6
 reRl5iiYEe2g7uo6qfCi7AHFzkts3bfALlNQQRI8hmYPgeklcpXbZwMG5/bUHhOP
 bSctO/OChnehB0iJMMceaJH+SPoPwFEnBDGzB7hxRsjvCsU0TCjMnLL6Y47DWezR
 sDx1zOcvGa5JNubXbFWfudp+5uemph2aQwxQzkgIx1PDswkBvC3MwdXD90l+mBoI
 EyOuIrl9PATsXzrJfz8ajK65bdN8FCUkNakUExUWLNCkJRfS8VQebg/jUOiLzq6r
 Ij38CrnrqstOYG5VaCIGqD1IBbS1EUExEkNkqR+vBqruFKyIrpT+Ef5O+EWUtQj+
 OHU2YI2ByVCMyIOjq+R/n8KPS1oTkM0J6PUyA1qlL75CMMB+L//GGr+nLyZ3ZgG0
 DORkT//M+dP5wEEzOpYGcOVAp8B5RJ83tia/GeHu2TQ2iiA18KuAXCG1TgjOVnnW
 zu/c8KVtFdqchwrxB5TCX831DHOkU67/1DcVNarOi+NPSIYWzI5RpDz6cfZ8g+wV
 YbEDlyQyG9CMDjIryjZK/w/PFOboRMTWoIzjK/VAGsbFsiwHq/zp+DmNK4Nux3NW
 pRP1oEceo6B5ajbFO4rn/5XtVPgi52T1BtbRNxp3gcu/6K/YfvekbZsnG6vV+0Es
 DshbVXr4hbbGjV2Ly//x
 =RgtQ
 -----END PGP SIGNATURE-----
 

Implement DataModel based read support in the interaction model engine. (#34419)

* Implement DataModel based read support in the interacton model engine.

This implements reads via ember and via codegen as well as a
checked-mode where reads are validated as returning the same
status codes and data size (because data content is not available)

* Comment update and logic update: we MAY get different sizes if data size changes for numbers

* Fix typo for ember implementation while renaming things

* Fix override markers

* run_tv_casting_test should be executable

* Do not report errors on chunking

* Typo fix

* move chipDie for tests only

* move all chipdie to unit test only

* fix comment and formatting

* Update encoderstate logic a bit - code is cleaner, will have to see if CI tests pass

* Restyle

* Enable tracing of messages for tv tests, to see what is going on in CI

* Restyle

* Start adding some log line processing for the tv tests, to have propper timeouts and not block on IO buffers

* Significant reformat and start refactoring the tv casting test

* TV tests pass

* Restyle

* Fix ruff

* Review comment update: set state in all cases

* Added a TODO regarding the awkward "callback on success only"

* Merge fix

* Update src/app/reporting/Read-Checked.cpp

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Review updates

* Fix placement of dm state

* Restyle

* Code review comments: double-check that IM not active when setting model, explain why we have the ifdef

* Code review: comment why we did not re-use code

* Code review feedback: warn if running in checked mode

* Restyle

* Avoid loop of err/out empty output

* Support a log directory argument for the casting tests, so I can debug their content

* Better debuggability and error reporting support for shell - this is to debug cast failures

---------

Co-authored-by: Andrei Litvin <andreilitvin@google.com>
Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>