| Flutter Linux Embedder |

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
flutter Namespace Reference

## Namespaces
| internal
| testing

## Classes
class | AccessibilityBridge
class | AlertPlatformNodeDelegate
class | BinaryMessengerImpl
class | ByteBufferStreamReader
class | ByteBufferStreamWriter
class | TestCustomValue
class | BasicMessageChannel
class | BinaryMessenger
class | ByteStreamReader
class | ByteStreamWriter
class | CustomEncodableValue
class | EncodableValue
class | EngineMethodResult
class | EventChannel
class | EventSink
struct | StreamHandlerError
class | StreamHandler
class | StreamHandlerFunctions
class | MessageCodec
class | MethodCall
class | MethodChannel
class | MethodCodec
class | MethodResult
class | MethodResultFunctions
class | PluginRegistrar
class | Plugin
class | PluginRegistrarManager
class | PluginRegistry
class | StandardCodecSerializer
class | StandardMessageCodec
class | StandardMethodCodec
class | PixelBufferTexture
class | GpuSurfaceTexture
class | TextureRegistrar
class | TextureRegistrarImpl
class | FlutterPlatformNodeDelegate
class | IncomingMessageDispatcher
class | Isolate
class | IsolateScope
class | JsonMessageCodec
class | JsonMethodCodec
class | TestAccessibilityBridge
struct | TextEditingDelta
| A change in the state of an input field. More...
class | TextInputModel
class | TextRange

## Typedefs
template<typename T >
using | MessageReply = std::function< void(const T &reply)>
template<typename T >
using | MessageHandler = std::function< void(const T &message, const MessageReply< T > &reply)>
typedef std::function< void(const uint8_t *reply, size_t reply_size)> | BinaryReply
typedef std::function< void(const uint8_t *message, size_t message_size, BinaryReply reply)> | BinaryMessageHandler
using | EncodableList = std::vector< EncodableValue >
using | EncodableMap = std::map< EncodableValue, EncodableValue >
template<typename T >
using | StreamHandlerListen = std::function< std::unique_ptr< StreamHandlerError< T > >(const T *arguments, std::unique_ptr< EventSink< T > > &&events)>
template<typename T >
using | StreamHandlerCancel = std::function< std::unique_ptr< StreamHandlerError< T > >(const T *arguments)>
template<typename T >
using | MethodCallHandler = std::function< void(const MethodCall< T > &call, std::unique_ptr< MethodResult< T > > result)>
template<typename T >
using | ResultHandlerSuccess = std::function< void(const T *result)>
template<typename T >
using | ResultHandlerError = std::function< void(const std::string &error_code, const std::string &error_message, const T *error_details)>
template<typename T >
using | ResultHandlerNotImplemented = std::function< void()>
typedef std::variant< PixelBufferTexture, GpuSurfaceTexture > | TextureVariant
typedef ui::AXNode::AXID | AccessibilityNodeId

## Enumerations
enum class | AppLifecycleState { kDetached , kResumed , kInactive , kHidden , kPaused }
enum class | PlatformProvidedMenu { kAbout , kQuit , kServicesSubmenu , kHide , kHideOtherApplications , kShowAllApplications , kStartSpeaking , kStopSpeaking , kToggleFullScreen , kMinimizeWindow , kZoomWindow , kArrangeWindowsInFront }
enum class | WindowArchetype { kRegular , kDialog }

## Functions
constexpr const char * | AppLifecycleStateToString (AppLifecycleState state)
| TEST (BasicMessageChannelTest, Registration)
| TEST (BasicMessageChannelTest, Unregistration)
| TEST (BasicMessageChannelTest, Resize)
| TEST (BasicMessageChannelTest, SetWarnsOnOverflow)
| TEST (EncodableValueTest, Null)
| TEST (EncodableValueTest, Bool)
| TEST (EncodableValueTest, Int)
| TEST (EncodableValueTest, LongValue)
| TEST (EncodableValueTest, Long)
| TEST (EncodableValueTest, Double)
| TEST (EncodableValueTest, String)
| TEST (EncodableValueTest, CString)
| TEST (EncodableValueTest, UInt8List)
| TEST (EncodableValueTest, Int32List)
| TEST (EncodableValueTest, Int64List)
| TEST (EncodableValueTest, DoubleList)
| TEST (EncodableValueTest, List)
| TEST (EncodableValueTest, Map)
| TEST (EncodableValueTest, Comparison)
| TEST (EncodableValueTest, DeepCopy)
| TEST (EncodableValueTest, TypeIndexesCorrect)
| TEST (EventChannelTest, Registration)
| TEST (EventChannelTest, Unregistration)
| TEST (EventChannelTest, Cancel)
| TEST (EventChannelTest, ListenNotCancel)
| TEST (EventChannelTest, ReRegistration)
| TEST (EventChannelTest, HandlerOutlivesEventChannel)
| TEST (EventChannelTest, StreamHandlerErrorPassByValue)
| TEST (EventChannelTest, StreamHandlerErrorNullptr)
| TEST (MethodCallTest, Basic)
| TEST (MethodChannelTest, Registration)
| TEST (MethodChannelTest, Unregistration)
| TEST (MethodChannelTest, InvokeWithoutResponse)
| TEST (MethodChannelTest, InvokeWithResponse)
| TEST (MethodChannelTest, InvokeNotImplemented)
| TEST (MethodChannelTest, Resize)
| TEST (MethodChannelTest, SetWarnsOnOverflow)
| TEST (MethodChannelTest, NoHandlers)
| TEST (MethodChannelTest, Success)
| TEST (MethodChannelTest, Error)
| TEST (MethodChannelTest, NotImplemented)
| TEST (PluginRegistrarTest, PluginDestroyedBeforeRegistrar)
| TEST (PluginRegistrarTest, MessengerSend)
| TEST (PluginRegistrarTest, MessengerSetMessageHandler)
| TEST (PluginRegistrarTest, ManagerSameInstance)
| TEST (PluginRegistrarTest, ManagerDifferentInstances)
| TEST (PluginRegistrarTest, ManagerRemovesOnDestruction)
| TEST (PluginRegistrarTest, TextureRegistrarNotNull)
static void | CheckEncodeDecode (const EncodableValue &value, const std::vector< uint8_t > &expected_encoding, const StandardCodecSerializer *serializer=nullptr, const std::function< bool(const EncodableValue &a, const EncodableValue &b)> &custom_comparator=nullptr)
static void | CheckEncodeDecodeWithEncodePrefix (const EncodableValue &value, const std::vector< uint8_t > &expected_encoding_prefix, size_t expected_encoding_length)
| TEST (StandardMessageCodec, GetInstanceCachesInstance)
| TEST (StandardMessageCodec, CanEncodeAndDecodeNull)
| TEST (StandardMessageCodec, CanDecodeEmptyBytesAsNullWithoutCallingSerializer)
| TEST (StandardMessageCodec, CanEncodeAndDecodeTrue)
| TEST (StandardMessageCodec, CanEncodeAndDecodeFalse)
| TEST (StandardMessageCodec, CanEncodeAndDecodeInt32)
| TEST (StandardMessageCodec, CanEncodeAndDecodeInt64)
| TEST (StandardMessageCodec, CanEncodeAndDecodeDouble)
| TEST (StandardMessageCodec, CanEncodeAndDecodeString)
| TEST (StandardMessageCodec, CanEncodeAndDecodeStringWithNonAsciiCodePoint)
| TEST (StandardMessageCodec, CanEncodeAndDecodeStringWithNonBMPCodePoint)
| TEST (StandardMessageCodec, CanEncodeAndDecodeEmptyString)
| TEST (StandardMessageCodec, CanEncodeAndDecodeList)
| TEST (StandardMessageCodec, CanEncodeAndDecodeEmptyList)
| TEST (StandardMessageCodec, CanEncodeAndDecodeMap)
| TEST (StandardMessageCodec, CanEncodeAndDecodeByteArray)
| TEST (StandardMessageCodec, CanEncodeAndDecodeInt32Array)
| TEST (StandardMessageCodec, CanEncodeAndDecodeInt64Array)
| TEST (StandardMessageCodec, CanEncodeAndDecodeFloat32Array)
| TEST (StandardMessageCodec, CanEncodeAndDecodeFloat64Array)
| TEST (StandardMessageCodec, CanEncodeAndDecodeSimpleCustomType)
| TEST (StandardMessageCodec, CanEncodeAndDecodeVariableLengthCustomType)
| TEST (StandardMethodCodec, GetInstanceCachesInstance)
| TEST (StandardMethodCodec, HandlesMethodCallsWithNullArguments)
| TEST (StandardMethodCodec, HandlesMethodCallsWithArgument)
| TEST (StandardMethodCodec, HandlesSuccessEnvelopesWithNullResult)
| TEST (StandardMethodCodec, HandlesSuccessEnvelopesWithResult)
| TEST (StandardMethodCodec, HandlesErrorEnvelopesWithNulls)
| TEST (StandardMethodCodec, HandlesErrorEnvelopesWithDetails)
| TEST (StandardMethodCodec, HandlesCustomTypeArguments)
| TEST (TextureRegistrarTest, RegisterUnregisterTexture)
| TEST (TextureRegistrarTest, UnregisterInvalidTexture)
| TEST (TextureRegistrarTest, MarkFrameAvailableInvalidTexture)
std::vector< std::string > | GetSwitchesFromEnvironment ()
| TEST (FlutterProjectBundle, SwitchesEmpty)
| TEST (FlutterProjectBundle, Switches)
| TEST (FlutterProjectBundle, SwitchesExtraValues)
| TEST (FlutterProjectBundle, SwitchesMissingValues)
| TEST (IncomingMessageDispatcher, SetHandle)
| TEST (IncomingMessageDispatcher, BlockInputFalse)
| TEST (IncomingMessageDispatcher, BlockInputTrue)
| TEST (JsonMessageCodec, EncodeDecode)
| TEST (JsonMethodCodec, HandlesMethodCallsWithNullArguments)
| TEST (JsonMethodCodec, HandlesMethodCallsWithArgument)
| TEST (JsonMethodCodec, HandlesSuccessEnvelopesWithNullResult)
| TEST (JsonMethodCodec, HandlesSuccessEnvelopesWithResult)
| TEST (JsonMethodCodec, HandlesErrorEnvelopesWithNulls)
| TEST (JsonMethodCodec, HandlesErrorEnvelopesWithDetails)
std::filesystem::path | GetExecutableDirectory ()
| TEST (PathUtilsTest, ExecutableDirector)
| TEST (TextEditingDeltaTest, TestTextEditingDeltaConstructor)
| TEST (TextEditingDeltaTest, TestTextEditingDeltaNonTextConstructor)
| TEST (TextInputModel, SetText)
| TEST (TextInputModel, SetTextWideCharacters)
| TEST (TextInputModel, SetTextEmpty)
| TEST (TextInputModel, SetTextReplaceText)
| TEST (TextInputModel, SetTextResetsSelection)
| TEST (TextInputModel, SetSelectionStart)
| TEST (TextInputModel, SetSelectionComposingStart)
| TEST (TextInputModel, SetSelectionMiddle)
| TEST (TextInputModel, SetSelectionComposingMiddle)
| TEST (TextInputModel, SetSelectionEnd)
| TEST (TextInputModel, SetSelectionComposingEnd)
| TEST (TextInputModel, SetSelectionWthExtent)
| TEST (TextInputModel, SetSelectionWthExtentComposing)
| TEST (TextInputModel, SetSelectionReverseExtent)
| TEST (TextInputModel, SetSelectionReverseExtentComposing)
| TEST (TextInputModel, SetSelectionOutsideString)
| TEST (TextInputModel, SetSelectionOutsideComposingRange)
| TEST (TextInputModel, SetComposingRangeStart)
| TEST (TextInputModel, SetComposingRangeMiddle)
| TEST (TextInputModel, SetComposingRangeEnd)
| TEST (TextInputModel, SetComposingRangeWithExtent)
| TEST (TextInputModel, SetComposingRangeReverseExtent)
| TEST (TextInputModel, SetComposingRangeOutsideString)
| TEST (TextInputModel, CommitComposingNoTextWithNoSelection)
| TEST (TextInputModel, CommitComposingNoTextWithSelection)
| TEST (TextInputModel, CommitComposingTextWithNoSelection)
| TEST (TextInputModel, CommitComposingTextWithSelection)
| TEST (TextInputModel, UpdateComposingRemovesLastComposingCharacter)
| TEST (TextInputModel, UpdateSelectionWhileComposing)
| TEST (TextInputModel, AddCodePoint)
| TEST (TextInputModel, AddCodePointSelection)
| TEST (TextInputModel, AddCodePointReverseSelection)
| TEST (TextInputModel, AddCodePointSelectionWideCharacter)
| TEST (TextInputModel, AddCodePointReverseSelectionWideCharacter)
| TEST (TextInputModel, AddText)
| TEST (TextInputModel, AddTextSelection)
| TEST (TextInputModel, AddTextReverseSelection)
| TEST (TextInputModel, AddTextSelectionWideCharacter)
| TEST (TextInputModel, AddTextReverseSelectionWideCharacter)
| TEST (TextInputModel, DeleteStart)
| TEST (TextInputModel, DeleteMiddle)
| TEST (TextInputModel, DeleteEnd)
| TEST (TextInputModel, DeleteWideCharacters)
| TEST (TextInputModel, DeleteSelection)
| TEST (TextInputModel, DeleteReverseSelection)
| TEST (TextInputModel, DeleteStartComposing)
| TEST (TextInputModel, DeleteStartReverseComposing)
| TEST (TextInputModel, DeleteMiddleComposing)
| TEST (TextInputModel, DeleteMiddleReverseComposing)
| TEST (TextInputModel, DeleteEndComposing)
| TEST (TextInputModel, DeleteEndReverseComposing)
| TEST (TextInputModel, DeleteSurroundingAtCursor)
| TEST (TextInputModel, DeleteSurroundingAtCursorComposing)
| TEST (TextInputModel, DeleteSurroundingAtCursorAll)
| TEST (TextInputModel, DeleteSurroundingAtCursorAllComposing)
| TEST (TextInputModel, DeleteSurroundingAtCursorGreedy)
| TEST (TextInputModel, DeleteSurroundingAtCursorGreedyComposing)
| TEST (TextInputModel, DeleteSurroundingBeforeCursor)
| TEST (TextInputModel, DeleteSurroundingBeforeCursorComposing)
| TEST (TextInputModel, DeleteSurroundingBeforeCursorAll)
| TEST (TextInputModel, DeleteSurroundingBeforeCursorAllComposing)
| TEST (TextInputModel, DeleteSurroundingBeforeCursorGreedy)
| TEST (TextInputModel, DeleteSurroundingBeforeCursorGreedyComposing)
| TEST (TextInputModel, DeleteSurroundingAfterCursor)
| TEST (TextInputModel, DeleteSurroundingAfterCursorComposing)
| TEST (TextInputModel, DeleteSurroundingAfterCursorAll)
| TEST (TextInputModel, DeleteSurroundingAfterCursorAllComposing)
| TEST (TextInputModel, DeleteSurroundingAfterCursorGreedy)
| TEST (TextInputModel, DeleteSurroundingAfterCursorGreedyComposing)
| TEST (TextInputModel, DeleteSurroundingSelection)
| TEST (TextInputModel, DeleteSurroundingReverseSelection)
| TEST (TextInputModel, BackspaceStart)
| TEST (TextInputModel, BackspaceMiddle)
| TEST (TextInputModel, BackspaceEnd)
| TEST (TextInputModel, BackspaceWideCharacters)
| TEST (TextInputModel, BackspaceSelection)
| TEST (TextInputModel, BackspaceReverseSelection)
| TEST (TextInputModel, BackspaceStartComposing)
| TEST (TextInputModel, BackspaceStartReverseComposing)
| TEST (TextInputModel, BackspaceMiddleComposing)
| TEST (TextInputModel, BackspaceMiddleReverseComposing)
| TEST (TextInputModel, BackspaceEndComposing)
| TEST (TextInputModel, BackspaceEndReverseComposing)
| TEST (TextInputModel, MoveCursorForwardStart)
| TEST (TextInputModel, MoveCursorForwardMiddle)
| TEST (TextInputModel, MoveCursorForwardEnd)
| TEST (TextInputModel, MoveCursorForwardWideCharacters)
| TEST (TextInputModel, MoveCursorForwardSelection)
| TEST (TextInputModel, MoveCursorForwardReverseSelection)
| TEST (TextInputModel, MoveCursorForwardStartComposing)
| TEST (TextInputModel, MoveCursorForwardStartReverseComposing)
| TEST (TextInputModel, MoveCursorForwardMiddleComposing)
| TEST (TextInputModel, MoveCursorForwardMiddleReverseComposing)
| TEST (TextInputModel, MoveCursorForwardEndComposing)
| TEST (TextInputModel, MoveCursorForwardEndReverseComposing)
| TEST (TextInputModel, MoveCursorBackStart)
| TEST (TextInputModel, MoveCursorBackMiddle)
| TEST (TextInputModel, MoveCursorBackEnd)
| TEST (TextInputModel, MoveCursorBackWideCharacters)
| TEST (TextInputModel, MoveCursorBackSelection)
| TEST (TextInputModel, MoveCursorBackReverseSelection)
| TEST (TextInputModel, MoveCursorBackStartComposing)
| TEST (TextInputModel, MoveCursorBackStartReverseComposing)
| TEST (TextInputModel, MoveCursorBackMiddleComposing)
| TEST (TextInputModel, MoveCursorBackMiddleReverseComposing)
| TEST (TextInputModel, MoveCursorBackEndComposing)
| TEST (TextInputModel, MoveCursorBackEndReverseComposing)
| TEST (TextInputModel, MoveCursorToBeginningStart)
| TEST (TextInputModel, SelectToBeginningStart)
| TEST (TextInputModel, MoveCursorToBeginningMiddle)
| TEST (TextInputModel, SelectToBeginningMiddle)
| TEST (TextInputModel, MoveCursorToBeginningEnd)
| TEST (TextInputModel, SelectToBeginningEnd)
| TEST (TextInputModel, MoveCursorToBeginningSelection)
| TEST (TextInputModel, SelectToBeginningSelection)
| TEST (TextInputModel, MoveCursorToBeginningReverseSelection)
| TEST (TextInputModel, SelectToBeginningReverseSelection)
| TEST (TextInputModel, MoveCursorToBeginningStartComposing)
| TEST (TextInputModel, SelectToBeginningStartComposing)
| TEST (TextInputModel, MoveCursorToBeginningStartReverseComposing)
| TEST (TextInputModel, SelectToBeginningStartReverseComposing)
| TEST (TextInputModel, MoveCursorToBeginningMiddleComposing)
| TEST (TextInputModel, SelectToBeginningMiddleComposing)
| TEST (TextInputModel, MoveCursorToBeginningMiddleReverseComposing)
| TEST (TextInputModel, SelectToBeginningMiddleReverseComposing)
| TEST (TextInputModel, MoveCursorToBeginningEndComposing)
| TEST (TextInputModel, SelectToBeginningEndComposing)
| TEST (TextInputModel, MoveCursorToBeginningEndReverseComposing)
| TEST (TextInputModel, SelectToBeginningEndReverseComposing)
| TEST (TextInputModel, MoveCursorToEndStart)
| TEST (TextInputModel, SelectToEndStart)
| TEST (TextInputModel, MoveCursorToEndMiddle)
| TEST (TextInputModel, SelectToEndMiddle)
| TEST (TextInputModel, MoveCursorToEndEnd)
| TEST (TextInputModel, SelectToEndEnd)
| TEST (TextInputModel, MoveCursorToEndSelection)
| TEST (TextInputModel, SelectToEndSelection)
| TEST (TextInputModel, MoveCursorToEndReverseSelection)
| TEST (TextInputModel, SelectToEndReverseSelection)
| TEST (TextInputModel, MoveCursorToEndStartComposing)
| TEST (TextInputModel, SelectToEndStartComposing)
| TEST (TextInputModel, MoveCursorToEndStartReverseComposing)
| TEST (TextInputModel, SelectToEndStartReverseComposing)
| TEST (TextInputModel, MoveCursorToEndMiddleComposing)
| TEST (TextInputModel, SelectToEndMiddleComposing)
| TEST (TextInputModel, MoveCursorToEndMiddleReverseComposing)
| TEST (TextInputModel, SelectToEndMiddleReverseComposing)
| TEST (TextInputModel, MoveCursorToEndEndComposing)
| TEST (TextInputModel, SelectToEndEndComposing)
| TEST (TextInputModel, MoveCursorToEndEndReverseComposing)
| TEST (TextInputModel, SelectToEndEndReverseComposing)
| TEST (TextInputModel, GetCursorOffset)
| TEST (TextInputModel, GetCursorOffsetSelection)
| TEST (TextInputModel, GetCursorOffsetReverseSelection)
| TEST (TextRange, TextRangeFromPositionZero)
| TEST (TextRange, TextRangeFromPositionNonZero)
| TEST (TextRange, TextRangeFromRange)
| TEST (TextRange, TextRangeFromReversedRange)
| TEST (TextRange, SetBase)
| TEST (TextRange, SetBaseReversed)
| TEST (TextRange, SetExtent)
| TEST (TextRange, SetExtentReversed)
| TEST (TextRange, SetStart)
| TEST (TextRange, SetStartReversed)
| TEST (TextRange, SetEnd)
| TEST (TextRange, SetEndReversed)
| TEST (TextRange, ContainsPreStartPosition)
| TEST (TextRange, ContainsStartPosition)
| TEST (TextRange, ContainsMiddlePosition)
| TEST (TextRange, ContainsEndPosition)
| TEST (TextRange, ContainsPostEndPosition)
| TEST (TextRange, ContainsPreStartPositionReversed)
| TEST (TextRange, ContainsStartPositionReversed)
| TEST (TextRange, ContainsMiddlePositionReversed)
| TEST (TextRange, ContainsEndPositionReversed)
| TEST (TextRange, ContainsPostEndPositionReversed)
| TEST (TextRange, ContainsRangePreStartPosition)
| TEST (TextRange, ContainsRangeSpanningStartPosition)
| TEST (TextRange, ContainsRangeStartPosition)
| TEST (TextRange, ContainsRangeMiddlePosition)
| TEST (TextRange, ContainsRangeEndPosition)
| TEST (TextRange, ContainsRangeSpanningEndPosition)
| TEST (TextRange, ContainsRangePostEndPosition)
| TEST (TextRange, ContainsRangePreStartPositionReversed)
| TEST (TextRange, ContainsRangeSpanningStartPositionReversed)
| TEST (TextRange, ContainsRangeStartPositionReversed)
| TEST (TextRange, ContainsRangeMiddlePositionReversed)
| TEST (TextRange, ContainsRangeSpanningEndPositionReversed)
| TEST (TextRange, ContainsRangeEndPositionReversed)
| TEST (TextRange, ContainsRangePostEndPositionReversed)
| TEST (TextRange, ReversedForwardRange)
| TEST (TextRange, ReversedCollapsedRange)
| TEST (TextRange, ReversedReversedRange)

## Variables
constexpr int | kHasScrollingAction

## Typedef Documentation

## ◆ AccessibilityNodeId

typedef ui::AXNode::AXID flutter::AccessibilityNodeId

Definition at line 15 of file flutter_platform_node_delegate.h.

## ◆ BinaryMessageHandler

typedef std::function< void(const uint8_t* message, size_t message_size, BinaryReply reply)> flutter::BinaryMessageHandler

Definition at line 25 of file binary_messenger.h.

## ◆ BinaryReply

typedef std::function<void(const uint8_t* reply, size_t reply_size)> flutter::BinaryReply

Definition at line 18 of file binary_messenger.h.

## ◆ EncodableList

using flutter::EncodableList = typedef std::vector<EncodableValue>

Definition at line 95 of file encodable_value.h.

## ◆ EncodableMap

using flutter::EncodableMap = typedef std::map<EncodableValue, EncodableValue>

Definition at line 96 of file encodable_value.h.

## ◆ MessageHandler

template<typename T >

using flutter::MessageHandler = typedef std::function<void(const T& message, const MessageReply<T>& reply)>

Definition at line 50 of file basic_message_channel.h.

## ◆ MessageReply

template<typename T >

using flutter::MessageReply = typedef std::function<void(const T& reply)>

Definition at line 43 of file basic_message_channel.h.

## ◆ MethodCallHandler

template<typename T >

using flutter::MethodCallHandler = typedef std::function<void(const MethodCall<T>& call, std::unique_ptr<MethodResult<T> > result)>

Definition at line 27 of file method_channel.h.

## ◆ ResultHandlerError

template<typename T >

using flutter::ResultHandlerError = typedef std::function<void(const std::string& error_code, const std::string& error_message, const T* error_details)>

Definition at line 22 of file method_result_functions.h.

## ◆ ResultHandlerNotImplemented

template<typename T >

using flutter::ResultHandlerNotImplemented = typedef std::function<void()>

Definition at line 26 of file method_result_functions.h.

## ◆ ResultHandlerSuccess

template<typename T >

using flutter::ResultHandlerSuccess = typedef std::function<void(const T* result)>

Definition at line 20 of file method_result_functions.h.

## ◆ StreamHandlerCancel

template<typename T >

using flutter::StreamHandlerCancel = typedef std::function<std::unique_ptr<StreamHandlerError<T> >(const T* arguments)>

Definition at line 26 of file event_stream_handler_functions.h.

## ◆ StreamHandlerListen

template<typename T >

using flutter::StreamHandlerListen = typedef std::function<std::unique_ptr<StreamHandlerError<T> >( const T* arguments, std::unique_ptr<EventSink<T> >&& events)>

Definition at line 20 of file event_stream_handler_functions.h.

## ◆ TextureVariant

typedef std::variant<PixelBufferTexture, GpuSurfaceTexture> flutter::TextureVariant

Definition at line 79 of file texture_registrar.h.

## Enumeration Type Documentation

## ◆ AppLifecycleState

enum flutter::AppLifecycleState
| strong

These constants describe the possible lifecycle states of the application. They must be kept up to date with changes in the framework's AppLifecycleState enum. They are passed to the embedder's |SetLifecycleState| function.

States not supported on a platform will be synthesized by the framework when transitioning between states which are supported, so that all implementations share the same state machine.

Here is the state machine:

    +-----------+                               +-----------+
    | detached  |------------------------------>|  resumed  |
    +-----------+                               +-----------+
         ^                                              ^
         |                                              |
         |                                              v
    +-----------+        +--------------+       +-----------+
    | paused    |<------>|    hidden    |<----->|  inactive |
    +-----------+        +--------------+       +-----------+

Enumerator
kDetached | Corresponds to the Framework's AppLifecycleState.detached: The initial state of the state machine. On Android, iOS, and web, also the final state of the state machine when all views are detached. Other platforms do not re-enter this state after initially leaving it.
kResumed | Corresponds to the Framework's AppLifecycleState.resumed: The nominal "running" state of the application. The application is visible, has input focus, and is running.
kInactive | Corresponds to the Framework's AppLifecycleState.inactive: At least one view of the application is visible, but none have input focus. The application is otherwise running normally.
kHidden | Corresponds to the Framework's AppLifecycleState.hidden: All views of an application are hidden, either because the application is being stopped (on iOS and Android), or because it is being minimized or on a desktop that is no longer visible (on desktop), or on a tab that is no longer visible (on web).
kPaused | Corresponds to the Framework's AppLifecycleState.paused: The application is not running, and can be detached or started again at any time. This state is typically only entered into on iOS and Android.

Definition at line 32 of file app_lifecycle_state.h.

32 {
33 /**
34 * Corresponds to the Framework's AppLifecycleState.detached: The initial
35 * state of the state machine. On Android, iOS, and web, also the final state
36 * of the state machine when all views are detached. Other platforms do not
37 * re-enter this state after initially leaving it.
38 */
39 kDetached,
40
41 /**
42 * Corresponds to the Framework's AppLifecycleState.resumed: The nominal
43 * "running" state of the application. The application is visible, has input
44 * focus, and is running.
45 */
46 kResumed,
47
48 /**
49 * Corresponds to the Framework's AppLifecycleState.inactive: At least one
50 * view of the application is visible, but none have input focus. The
51 * application is otherwise running normally.
52 */
53 kInactive,
54
55 /**
56 * Corresponds to the Framework's AppLifecycleState.hidden: All views of an
57 * application are hidden, either because the application is being stopped (on
58 * iOS and Android), or because it is being minimized or on a desktop that is
59 * no longer visible (on desktop), or on a tab that is no longer visible (on
60 * web).
61 */
62 kHidden,
63
64 /**
65 * Corresponds to the Framework's AppLifecycleState.paused: The application is
66 * not running, and can be detached or started again at any time. This state
67 * is typically only entered into on iOS and Android.
68 */
69 kPaused,
70 };
flutter::AppLifecycleState::kPaused
@ kPaused
flutter::AppLifecycleState::kDetached
@ kDetached
flutter::AppLifecycleState::kHidden
@ kHidden
flutter::AppLifecycleState::kResumed
@ kResumed
flutter::AppLifecycleState::kInactive
@ kInactive

## ◆ PlatformProvidedMenu

enum flutter::PlatformProvidedMenu
| strong

Enumerator
kAbout |
kQuit |
kServicesSubmenu |
kHide |
kHideOtherApplications |
kShowAllApplications |
kStartSpeaking |
kStopSpeaking |
kToggleFullScreen |
kMinimizeWindow |
kZoomWindow |
kArrangeWindowsInFront |

Definition at line 12 of file platform_provided_menu.h.

12 {
13 // orderFrontStandardAboutPanel macOS provided menu
14 kAbout,
15
16 // terminate macOS provided menu
17 kQuit,
18
19 // Services macOS provided submenu.
20 kServicesSubmenu,
21
22 // hide macOS provided menu
23 kHide,
24
25 // hideOtherApplications macOS provided menu
26 kHideOtherApplications,
27
28 // unhideAllApplications macOS provided menu
29 kShowAllApplications,
30
31 // startSpeaking macOS provided menu
32 kStartSpeaking,
33
34 // stopSpeaking macOS provided menu
35 kStopSpeaking,
36
37 // toggleFullScreen macOS provided menu
38 kToggleFullScreen,
39
40 // performMiniaturize macOS provided menu
41 kMinimizeWindow,
42
43 // performZoom macOS provided menu
44 kZoomWindow,
45
46 // arrangeInFront macOS provided menu
47 kArrangeWindowsInFront,
48 };
flutter::PlatformProvidedMenu::kQuit
@ kQuit
flutter::PlatformProvidedMenu::kMinimizeWindow
@ kMinimizeWindow
flutter::PlatformProvidedMenu::kArrangeWindowsInFront
@ kArrangeWindowsInFront
flutter::PlatformProvidedMenu::kHide
@ kHide
flutter::PlatformProvidedMenu::kAbout
@ kAbout
flutter::PlatformProvidedMenu::kHideOtherApplications
@ kHideOtherApplications
flutter::PlatformProvidedMenu::kServicesSubmenu
@ kServicesSubmenu
flutter::PlatformProvidedMenu::kToggleFullScreen
@ kToggleFullScreen
flutter::PlatformProvidedMenu::kStartSpeaking
@ kStartSpeaking
flutter::PlatformProvidedMenu::kStopSpeaking
@ kStopSpeaking
flutter::PlatformProvidedMenu::kShowAllApplications
@ kShowAllApplications
flutter::PlatformProvidedMenu::kZoomWindow
@ kZoomWindow

## ◆ WindowArchetype

enum flutter::WindowArchetype
| strong

Enumerator
kRegular |
kDialog |

Definition at line 11 of file windowing.h.

11 {
12 // Regular top-level window.
13 kRegular,
14
15 // Dialog window.
16 kDialog,
17 };
flutter::WindowArchetype::kRegular
@ kRegular
flutter::WindowArchetype::kDialog
@ kDialog

## Function Documentation

## ◆ AppLifecycleStateToString()

constexpr const char* flutter::AppLifecycleStateToString | ( | AppLifecycleState | state | ) |
| constexpr

Definition at line 72 of file app_lifecycle_state.h.

72 {
73 switch (state) {
74 case AppLifecycleState::kDetached:
75 return "AppLifecycleState.detached";
76 case AppLifecycleState::kResumed:
77 return "AppLifecycleState.resumed";
78 case AppLifecycleState::kInactive:
79 return "AppLifecycleState.inactive";
80 case AppLifecycleState::kHidden:
81 return "AppLifecycleState.hidden";
82 case AppLifecycleState::kPaused:
83 return "AppLifecycleState.paused";
84 }
85 }

References kDetached, kHidden, kInactive, kPaused, and kResumed.

## ◆ CheckEncodeDecode()

static void flutter::CheckEncodeDecode | ( | const EncodableValue & | value,
|  | const std::vector< uint8_t > & | expected_encoding,
|  | const StandardCodecSerializer * | serializer = `nullptr`,
|  | const std::function< bool(const EncodableValue &a, const EncodableValue &b)> & | custom_comparator = `nullptr`
| ) |  |
| static

Definition at line 37 of file standard_message_codec_unittests.cc.

42 {
43 const StandardMessageCodec& codec =
44 StandardMessageCodec::GetInstance(serializer);
45 auto encoded = codec.EncodeMessage(value);
46 ASSERT_TRUE(encoded);
47 EXPECT_EQ(*encoded, expected_encoding);
48
49 auto decoded = codec.DecodeMessage(*encoded);
50 if (custom_comparator) {
51 EXPECT_TRUE(custom_comparator(value, *decoded));
52 } else {
53 EXPECT_EQ(value, *decoded);
54 }
55 }
value
uint8_t value
Definition: fl_standard_message_codec.cc:36

References flutter::MessageCodec< T >::DecodeMessage(), flutter::MessageCodec< T >::EncodeMessage(), flutter::StandardMessageCodec::GetInstance(), and value.

Referenced by TEST().

## ◆ CheckEncodeDecodeWithEncodePrefix()

static void flutter::CheckEncodeDecodeWithEncodePrefix | ( | const EncodableValue & | value,
|  | const std::vector< uint8_t > & | expected_encoding_prefix,
|  | size_t | expected_encoding_length
| ) |  |
| static

Definition at line 62 of file standard_message_codec_unittests.cc.

65 {
66 EXPECT_TRUE(std::holds_alternative<EncodableMap>(value));
67 const StandardMessageCodec& codec = StandardMessageCodec::GetInstance();
68 auto encoded = codec.EncodeMessage(value);
69 ASSERT_TRUE(encoded);
70
71 EXPECT_EQ(encoded->size(), expected_encoding_length);
72 ASSERT_GT(encoded->size(), expected_encoding_prefix.size());
73 EXPECT_TRUE(std::equal(
74 encoded->begin(), encoded->begin() + expected_encoding_prefix.size(),
75 expected_encoding_prefix.begin(), expected_encoding_prefix.end()));
76
77 auto decoded = codec.DecodeMessage(*encoded);
78
79 EXPECT_EQ(value, *decoded);
80 }

References flutter::MessageCodec< T >::DecodeMessage(), flutter::MessageCodec< T >::EncodeMessage(), flutter::StandardMessageCodec::GetInstance(), and value.

Referenced by TEST().

## ◆ GetExecutableDirectory()

std::filesystem::path flutter::GetExecutableDirectory | ( |  | ) |

Definition at line 16 of file path_utils.cc.

16 {
17 #if defined(_WIN32)
18 wchar_t buffer[MAX_PATH];
19 if (GetModuleFileName(nullptr, buffer, MAX_PATH) == 0) {
20 return std::filesystem::path();
21 }
22 std::filesystem::path executable_path(buffer);
23 return executable_path.remove_filename();
24 #elif defined(__linux__)
25 char buffer[PATH_MAX + 1];
26 ssize_t length = readlink("/proc/self/exe", buffer, sizeof(buffer));
27 if (length > PATH_MAX) {
28 return std::filesystem::path();
29 }
30 std::filesystem::path executable_path(std::string(buffer, length));
31 return executable_path.remove_filename();
32 #else
33 return std::filesystem::path();
34 #endif
35 }
buffer
static const uint8_t buffer[]
Definition: fl_pixel_buffer_texture_test.cc:44
length
size_t length
Definition: fl_standard_message_codec_test.cc:1115

References buffer, and length.

Referenced by TEST().

## ◆ GetSwitchesFromEnvironment()

std::vector< std::string > flutter::GetSwitchesFromEnvironment | ( |  | ) |

Definition at line 14 of file engine_switches.cc.

14 {
15 std::vector<std::string> switches;
16 // Read engine switches from the environment in debug/profile. If release mode
17 // support is needed in the future, it should likely use a whitelist.
18 #ifndef FLUTTER_RELEASE
19 const char* switch_count_key = "FLUTTER_ENGINE_SWITCHES";
20 const int kMaxSwitchCount = 50;
21 const char* switch_count_string = std::getenv(switch_count_key);
22 if (!switch_count_string) {
23 return switches;
24 }
25 int switch_count = std::min(kMaxSwitchCount, atoi(switch_count_string));
26 for (int i = 1; i <= switch_count; ++i) {
27 std::ostringstream switch_key;
28 switch_key << "FLUTTER_ENGINE_SWITCH_" << i;
29 const char* switch_value = std::getenv(switch_key.str().c_str());
30 if (switch_value) {
31 std::ostringstream switch_value_as_flag;
32 switch_value_as_flag << "--" << switch_value;
33 switches.push_back(switch_value_as_flag.str());
34 } else {
35 std::cerr << switch_count << " keys expected from " << switch_count_key
36 << ", but " << switch_key.str() << " is missing." << std::endl;
37 }
38 }
39 #endif // !FLUTTER_RELEASE
40 return switches;
41 }
i
int i
Definition: fl_socket_accessible.cc:18

References i.

Referenced by fl_engine_start(), and TEST().

## ◆ TEST() [1/291]

flutter::TEST | ( | BasicMessageChannelTest | ,
|  | Registration |
| ) |  |

Definition at line 58 of file basic_message_channel_unittests.cc.

58 {
59 TestBinaryMessenger messenger;
60 const std::string channel_name("some_channel");
61 const StandardMessageCodec& codec = StandardMessageCodec::GetInstance();
62 BasicMessageChannel channel(&messenger, channel_name, &codec);
63
64 bool callback_called = false;
65 const std::string message_value("hello");
66 channel.SetMessageHandler([&callback_called, message_value](
67 const auto& message, const auto& reply) {
68 callback_called = true;
69 // Ensure that the wrapper received a correctly decoded message and a
70 // reply.
71 EXPECT_EQ(std::get<std::string>(message), message_value);
72 EXPECT_NE(reply, nullptr);
73 });
74 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
75 EXPECT_NE(messenger.last_message_handler(), nullptr);
76 // Send a test message to trigger the handler test assertions.
77 auto message = codec.EncodeMessage(EncodableValue(message_value));
78
79 messenger.last_message_handler()(
80 message->data(), message->size(),
81 [](const uint8_t* reply, const size_t reply_size) {});
82 EXPECT_EQ(callback_called, true);
83 }
message
const char * message
Definition: fl_accessibility_handler.cc:21

References flutter::MessageCodec< T >::EncodeMessage(), flutter::StandardMessageCodec::GetInstance(), message, and flutter::BasicMessageChannel< T >::SetMessageHandler().

## ◆ TEST() [2/291]

flutter::TEST | ( | BasicMessageChannelTest | ,
|  | Resize |
| ) |  |

Definition at line 103 of file basic_message_channel_unittests.cc.

103 {
104 TestBinaryMessenger messenger;
105 const std::string channel_name("flutter/test");
106 BasicMessageChannel channel(&messenger, channel_name,
107 &flutter::StandardMessageCodec::GetInstance());
108
109 channel.Resize(3);
110
111 // Because the Dart implementation for the control channel implements its own
112 // custom deserialization logic, this test compares the generated bytes array
113 // to the expected one (for instance, the deserialization logic expects the
114 // size parameter of the resize method call to be an uint32).
115 //
116 // The expected content was created from the following Dart code:
117 // MethodCall call = MethodCall('resize', ['flutter/test',3]);
118 // StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
119 const int expected_message_size = 29;
120
121 EXPECT_EQ(messenger.send_called(), true);
122 EXPECT_EQ(static_cast<int>(messenger.last_message().size()),
123 expected_message_size);
124
125 int expected[expected_message_size] = {
126 7, 6, 114, 101, 115, 105, 122, 101, 12, 2, 7, 12, 102, 108, 117,
127 116, 116, 101, 114, 47, 116, 101, 115, 116, 3, 3, 0, 0, 0};
128 for (int i = 0; i < expected_message_size; i++) {
129 EXPECT_EQ(messenger.last_message()[i], expected[i]);
130 }
131 }
flutter::StandardMessageCodec::GetInstance
static const StandardMessageCodec & GetInstance(const StandardCodecSerializer *serializer=nullptr)
Definition: standard_codec.cc:293

References flutter::StandardMessageCodec::GetInstance(), i, and flutter::BasicMessageChannel< T >::Resize().

## ◆ TEST() [3/291]

flutter::TEST | ( | BasicMessageChannelTest | ,
|  | SetWarnsOnOverflow |
| ) |  |

Definition at line 135 of file basic_message_channel_unittests.cc.

135 {
136 TestBinaryMessenger messenger;
137
138 const std::string channel_name("flutter/test");
139 BasicMessageChannel channel(&messenger, channel_name,
140 &flutter::StandardMessageCodec::GetInstance());
141
142 channel.SetWarnsOnOverflow(false);
143
144 // Because the Dart implementation for the control channel implements its own
145 // custom deserialization logic, this test compares the generated bytes array
146 // to the expected one.
147 //
148 // The expected content was created from the following Dart code:
149 // MethodCall call = MethodCall('overflow',['flutter/test', true]);
150 // StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
151 const int expected_message_size = 27;
152
153 EXPECT_EQ(messenger.send_called(), true);
154 EXPECT_EQ(static_cast<int>(messenger.last_message().size()),
155 expected_message_size);
156
157 int expected[expected_message_size] = {
158 7, 8, 111, 118, 101, 114, 102, 108, 111, 119, 12, 2, 7, 12,
159 102, 108, 117, 116, 116, 101, 114, 47, 116, 101, 115, 116, 1};
160 for (int i = 0; i < expected_message_size; i++) {
161 EXPECT_EQ(messenger.last_message()[i], expected[i]);
162 }
163 }

References flutter::StandardMessageCodec::GetInstance(), i, and flutter::BasicMessageChannel< T >::SetWarnsOnOverflow().

## ◆ TEST() [4/291]

flutter::TEST | ( | BasicMessageChannelTest | ,
|  | Unregistration |
| ) |  |

Definition at line 86 of file basic_message_channel_unittests.cc.

86 {
87 TestBinaryMessenger messenger;
88 const std::string channel_name("some_channel");
89 BasicMessageChannel channel(&messenger, channel_name,
90 &flutter::StandardMessageCodec::GetInstance());
91
92 channel.SetMessageHandler([](const auto& message, const auto& reply) {});
93 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
94 EXPECT_NE(messenger.last_message_handler(), nullptr);
95
96 channel.SetMessageHandler(nullptr);
97 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
98 EXPECT_EQ(messenger.last_message_handler(), nullptr);
99 }

References flutter::StandardMessageCodec::GetInstance(), message, and flutter::BasicMessageChannel< T >::SetMessageHandler().

## ◆ TEST() [5/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Bool |
| ) |  |

Definition at line 18 of file encodable_value_unittests.cc.

18 {
19 EncodableValue value(false);
20
21 EXPECT_FALSE(std::get<bool>(value));
22 value = true;
23 EXPECT_TRUE(std::get<bool>(value));
24 }

References value.

## ◆ TEST() [6/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Comparison |
| ) |  |

Definition at line 177 of file encodable_value_unittests.cc.

177 {
178 EncodableList values = {
179 // Null
180 EncodableValue(),
181 // Bool
182 EncodableValue(true),
183 EncodableValue(false),
184 // Int
185 EncodableValue(-7),
186 EncodableValue(0),
187 EncodableValue(100),
188 // Long
189 EncodableValue(INT64_C(-7)),
190 EncodableValue(INT64_C(0)),
191 EncodableValue(INT64_C(100)),
192 // Double
193 EncodableValue(-7.0),
194 EncodableValue(0.0),
195 EncodableValue(100.0),
196 // String
197 EncodableValue("one"),
198 EncodableValue("two"),
199 // ByteList
200 EncodableValue(std::vector<uint8_t>{0, 1}),
201 EncodableValue(std::vector<uint8_t>{0, 10}),
202 // IntList
203 EncodableValue(std::vector<int32_t>{0, 1}),
204 EncodableValue(std::vector<int32_t>{0, 100}),
205 // LongList
206 EncodableValue(std::vector<int64_t>{0, INT64_C(1)}),
207 EncodableValue(std::vector<int64_t>{0, INT64_C(100)}),
208 // DoubleList
209 EncodableValue(std::vector<double>{0, INT64_C(1)}),
210 EncodableValue(std::vector<double>{0, INT64_C(100)}),
211 // List
212 EncodableValue(EncodableList{EncodableValue(), EncodableValue(true)}),
213 EncodableValue(EncodableList{EncodableValue(), EncodableValue(1.0)}),
214 // Map
215 EncodableValue(EncodableMap{{EncodableValue(), EncodableValue(true)},
216 {EncodableValue(7), EncodableValue(7.0)}}),
217 EncodableValue(
218 EncodableMap{{EncodableValue(), EncodableValue(1.0)},
219 {EncodableValue("key"), EncodableValue("value")}}),
220 // FloatList
221 EncodableValue(std::vector<float>{0, 1}),
222 EncodableValue(std::vector<float>{0, 100}),
223 };
224
225 for (size_t i = 0; i < values.size(); ++i) {
226 const auto& a = values[i];
227 for (size_t j = 0; j < values.size(); ++j) {
228 const auto& b = values[j];
229 if (i == j) {
230 // Identical objects should always be equal.
231 EXPECT_FALSE(a < b);
232 EXPECT_FALSE(b < a);
233 } else {
234 // All other comparisons should be consistent, but the direction doesn't
235 // matter.
236 EXPECT_NE(a < b, b < a) << "Indexes: " << i << ", " << j;
237 }
238 }
239
240 // Copies should always be equal.
241 EncodableValue copy(a);
242 EXPECT_FALSE(a < copy || copy < a);
243 }
244 }
flutter::EncodableList
std::vector< EncodableValue > EncodableList
Definition: encodable_value.h:95
flutter::EncodableMap
std::map< EncodableValue, EncodableValue > EncodableMap
Definition: encodable_value.h:96

References i.

## ◆ TEST() [7/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | CString |
| ) |  |

Definition at line 68 of file encodable_value_unittests.cc.

68 {
69 const char* hello = "Hello, world!";
70 EncodableValue value(hello);
71
72 EXPECT_EQ(std::get<std::string>(value), hello);
73 value = "Goodbye";
74 EXPECT_EQ(std::get<std::string>(value), "Goodbye");
75 }

References value.

## ◆ TEST() [8/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | DeepCopy |
| ) |  |

Definition at line 247 of file encodable_value_unittests.cc.

247 {
248 EncodableList original = {
249 EncodableValue(EncodableMap{
250 {EncodableValue(), EncodableValue(std::vector<int32_t>{1, 2, 3})},
251 {EncodableValue(1), EncodableValue(INT64_C(0000))},
252 {EncodableValue("two"), EncodableValue(7)},
253 }),
254 EncodableValue(EncodableList{
255 EncodableValue(),
256 EncodableValue(),
257 EncodableValue(
258 EncodableMap{{EncodableValue("a"), EncodableValue("b")}}),
259 }),
260 };
261
262 EncodableValue copy(original);
263 ASSERT_TRUE(std::holds_alternative<EncodableList>(copy));
264
265 // Spot-check innermost collection values.
266 auto& root_list = std::get<EncodableList>(copy);
267 auto& first_child = std::get<EncodableMap>(root_list[0]);
268 EXPECT_EQ(std::get<int32_t>(first_child[EncodableValue("two")]), 7);
269 auto& second_child = std::get<EncodableList>(root_list[1]);
270 auto& innermost_map = std::get<EncodableMap>(second_child[2]);
271 EXPECT_EQ(std::get<std::string>(innermost_map[EncodableValue("a")]), "b");
272
273 // Modify those values in the original structure.
274 first_child[EncodableValue("two")] = EncodableValue();
275 innermost_map[EncodableValue("a")] = 99;
276
277 // Re-check innermost collection values of the original to ensure that they
278 // haven't changed.
279 first_child = std::get<EncodableMap>(original[0]);
280 EXPECT_EQ(std::get<int32_t>(first_child[EncodableValue("two")]), 7);
281 second_child = std::get<EncodableList>(original[1]);
282 innermost_map = std::get<EncodableMap>(second_child[2]);
283 EXPECT_EQ(std::get<std::string>(innermost_map[EncodableValue("a")]), "b");
284 }

## ◆ TEST() [9/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Double |
| ) |  |

Definition at line 50 of file encodable_value_unittests.cc.

50 {
51 EncodableValue value(3.14);
52
53 EXPECT_EQ(std::get<double>(value), 3.14);
54 value = std::numeric_limits<double>::max();
55 EXPECT_EQ(std::get<double>(value), std::numeric_limits<double>::max());
56 }

References value.

## ◆ TEST() [10/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | DoubleList |
| ) |  |

Definition at line 119 of file encodable_value_unittests.cc.

119 {
120 std::vector<double> data = {-10.0, 2.0};
121 EncodableValue value(data);
122
123 auto& list_value = std::get<std::vector<double>>(value);
124 list_value.push_back(std::numeric_limits<double>::max());
125 EXPECT_EQ(list_value[0], -10.0);
126 EXPECT_EQ(list_value[1], 2.0);
127
128 ASSERT_EQ(list_value.size(), 3u);
129 EXPECT_EQ(data.size(), 2u);
130 EXPECT_EQ(list_value[2], std::numeric_limits<double>::max());
131 }

References value.

## ◆ TEST() [11/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Int |
| ) |  |

Definition at line 26 of file encodable_value_unittests.cc.

26 {
27 EncodableValue value(42);
28
29 EXPECT_EQ(std::get<int32_t>(value), 42);
30 value = std::numeric_limits<int32_t>::max();
31 EXPECT_EQ(std::get<int32_t>(value), std::numeric_limits<int32_t>::max());
32 }

References value.

## ◆ TEST() [12/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Int32List |
| ) |  |

Definition at line 91 of file encodable_value_unittests.cc.

91 {
92 std::vector<int32_t> data = {-10, 2};
93 EncodableValue value(data);
94
95 auto& list_value = std::get<std::vector<int32_t>>(value);
96 list_value.push_back(std::numeric_limits<int32_t>::max());
97 EXPECT_EQ(list_value[0], -10);
98 EXPECT_EQ(list_value[1], 2);
99
100 ASSERT_EQ(list_value.size(), 3u);
101 EXPECT_EQ(data.size(), 2u);
102 EXPECT_EQ(list_value[2], std::numeric_limits<int32_t>::max());
103 }

References value.

## ◆ TEST() [13/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Int64List |
| ) |  |

Definition at line 105 of file encodable_value_unittests.cc.

105 {
106 std::vector<int64_t> data = {-10, 2};
107 EncodableValue value(data);
108
109 auto& list_value = std::get<std::vector<int64_t>>(value);
110 list_value.push_back(std::numeric_limits<int64_t>::max());
111 EXPECT_EQ(list_value[0], -10);
112 EXPECT_EQ(list_value[1], 2);
113
114 ASSERT_EQ(list_value.size(), 3u);
115 EXPECT_EQ(data.size(), 2u);
116 EXPECT_EQ(list_value[2], std::numeric_limits<int64_t>::max());
117 }

References value.

## ◆ TEST() [14/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | List |
| ) |  |

Definition at line 133 of file encodable_value_unittests.cc.

133 {
134 EncodableList encodables = {
135 EncodableValue(1),
136 EncodableValue(2.0),
137 EncodableValue("Three"),
138 };
139 EncodableValue value(encodables);
140
141 auto& list_value = std::get<EncodableList>(value);
142 EXPECT_EQ(std::get<int32_t>(list_value[0]), 1);
143 EXPECT_EQ(std::get<double>(list_value[1]), 2.0);
144 EXPECT_EQ(std::get<std::string>(list_value[2]), "Three");
145
146 // Ensure that it's a modifiable copy of the original array.
147 list_value.push_back(EncodableValue(true));
148 ASSERT_EQ(list_value.size(), 4u);
149 EXPECT_EQ(encodables.size(), 3u);
150 EXPECT_EQ(std::get<bool>(std::get<EncodableList>(value)[3]), true);
151 }

References value.

## ◆ TEST() [15/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Long |
| ) |  |

Definition at line 42 of file encodable_value_unittests.cc.

42 {
43 EncodableValue value(INT64_C(42));
44
45 EXPECT_EQ(std::get<int64_t>(value), 42);
46 value = std::numeric_limits<int64_t>::max();
47 EXPECT_EQ(std::get<int64_t>(value), std::numeric_limits<int64_t>::max());
48 }

References value.

## ◆ TEST() [16/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | LongValue |
| ) |  |

Definition at line 35 of file encodable_value_unittests.cc.

35 {
36 const EncodableValue int_value(std::numeric_limits<int32_t>::max());
37 EXPECT_EQ(int_value.LongValue(), std::numeric_limits<int32_t>::max());
38 const EncodableValue long_value(std::numeric_limits<int64_t>::max());
39 EXPECT_EQ(long_value.LongValue(), std::numeric_limits<int64_t>::max());
40 }

References flutter::EncodableValue::LongValue().

## ◆ TEST() [17/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Map |
| ) |  |

Definition at line 153 of file encodable_value_unittests.cc.

153 {
154 EncodableMap encodables = {
155 {EncodableValue(), EncodableValue(std::vector<int32_t>{1, 2, 3})},
156 {EncodableValue(1), EncodableValue(INT64_C(10000))},
157 {EncodableValue("two"), EncodableValue(7)},
158 };
159 EncodableValue value(encodables);
160
161 auto& map_value = std::get<EncodableMap>(value);
162 EXPECT_EQ(
163 std::holds_alternative<std::vector<int32_t>>(map_value[EncodableValue()]),
164 true);
165 EXPECT_EQ(std::get<int64_t>(map_value[EncodableValue(1)]), INT64_C(10000));
166 EXPECT_EQ(std::get<int32_t>(map_value[EncodableValue("two")]), 7);
167
168 // Ensure that it's a modifiable copy of the original map.
169 map_value[EncodableValue(true)] = EncodableValue(false);
170 ASSERT_EQ(map_value.size(), 4u);
171 EXPECT_EQ(encodables.size(), 3u);
172 EXPECT_EQ(std::get<bool>(map_value[EncodableValue(true)]), false);
173 }

References value.

## ◆ TEST() [18/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | Null |
| ) |  |

Definition at line 13 of file encodable_value_unittests.cc.

13 {
14 EncodableValue value;
15 value.IsNull();
16 }

References value.

## ◆ TEST() [19/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | String |
| ) |  |

Definition at line 58 of file encodable_value_unittests.cc.

58 {
59 std::string hello("Hello, world!");
60 EncodableValue value(hello);
61
62 EXPECT_EQ(std::get<std::string>(value), hello);
63 value = std::string("Goodbye");
64 EXPECT_EQ(std::get<std::string>(value), "Goodbye");
65 }

References value.

## ◆ TEST() [20/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | TypeIndexesCorrect |
| ) |  |

Definition at line 301 of file encodable_value_unittests.cc.

301 {
302 // Null
303 EXPECT_EQ(EncodableValue().index(), 0u);
304 // Bool
305 EXPECT_EQ(EncodableValue(true).index(), 1u);
306 // Int32
307 EXPECT_EQ(EncodableValue(100).index(), 2u);
308 // Int64
309 EXPECT_EQ(EncodableValue(INT64_C(100)).index(), 3u);
310 // Double
311 EXPECT_EQ(EncodableValue(7.0).index(), 4u);
312 // String
313 EXPECT_EQ(EncodableValue("one").index(), 5u);
314 // ByteList
315 EXPECT_EQ(EncodableValue(std::vector<uint8_t>()).index(), 6u);
316 // IntList
317 EXPECT_EQ(EncodableValue(std::vector<int32_t>()).index(), 7u);
318 // LongList
319 EXPECT_EQ(EncodableValue(std::vector<int64_t>()).index(), 8u);
320 // DoubleList
321 EXPECT_EQ(EncodableValue(std::vector<double>()).index(), 9u);
322 // List
323 EXPECT_EQ(EncodableValue(EncodableList()).index(), 10u);
324 // Map
325 EXPECT_EQ(EncodableValue(EncodableMap()).index(), 11u);
326 // Custom type
327 TestCustomValue customValue;
328 EXPECT_EQ(((EncodableValue)CustomEncodableValue(customValue)).index(), 12u);
329 // FloatList
330 EXPECT_EQ(EncodableValue(std::vector<float>()).index(), 13u);
331 } // namespace flutter

## ◆ TEST() [21/291]

flutter::TEST | ( | EncodableValueTest | ,
|  | UInt8List |
| ) |  |

Definition at line 77 of file encodable_value_unittests.cc.

77 {
78 std::vector<uint8_t> data = {0, 2};
79 EncodableValue value(data);
80
81 auto& list_value = std::get<std::vector<uint8_t>>(value);
82 list_value.push_back(std::numeric_limits<uint8_t>::max());
83 EXPECT_EQ(list_value[0], 0);
84 EXPECT_EQ(list_value[1], 2);
85
86 ASSERT_EQ(list_value.size(), 3u);
87 EXPECT_EQ(data.size(), 2u);
88 EXPECT_EQ(list_value[2], std::numeric_limits<uint8_t>::max());
89 }

References value.

## ◆ TEST() [22/291]

flutter::TEST | ( | EventChannelTest | ,
|  | Cancel |
| ) |  |

Definition at line 102 of file event_channel_unittests.cc.

102 {
103 TestBinaryMessenger messenger;
104 const std::string channel_name("some_channel");
105 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
106 EventChannel channel(&messenger, channel_name, &codec);
107
108 bool on_listen_called = false;
109 bool on_cancel_called = false;
110 auto handler = std::make_unique<StreamHandlerFunctions<>>(
111 [&on_listen_called](const EncodableValue* arguments,
112 std::unique_ptr<EventSink<>>&& events)
113 -> std::unique_ptr<StreamHandlerError<>> {
114 on_listen_called = true;
115 return nullptr;
116 },
117 [&on_cancel_called](const EncodableValue* arguments)
118 -> std::unique_ptr<StreamHandlerError<>> {
119 on_cancel_called = true;
120 return nullptr;
121 });
122 channel.SetStreamHandler(std::move(handler));
123 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
124 EXPECT_NE(messenger.last_message_handler(), nullptr);
125
126 // Send test listen message.
127 MethodCall<> call_listen("listen", nullptr);
128 auto message = codec.EncodeMethodCall(call_listen);
129 messenger.last_message_handler()(
130 message->data(), message->size(),
131 [](const uint8_t* reply, const size_t reply_size) {});
132 EXPECT_EQ(on_listen_called, true);
133
134 // Send test cancel message.
135 MethodCall<> call_cancel("cancel", nullptr);
136 message = codec.EncodeMethodCall(call_cancel);
137 messenger.last_message_handler()(
138 message->data(), message->size(),
139 [](const uint8_t* reply, const size_t reply_size) {});
140
141 // Check results.
142 EXPECT_EQ(on_cancel_called, true);
143 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), message, and flutter::EventChannel< T >::SetStreamHandler().

## ◆ TEST() [23/291]

flutter::TEST | ( | EventChannelTest | ,
|  | HandlerOutlivesEventChannel |
| ) |  |

Definition at line 232 of file event_channel_unittests.cc.

232 {
233 TestBinaryMessenger messenger;
234 const std::string channel_name("some_channel");
235 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
236
237 bool on_listen_called = false;
238 bool on_cancel_called = false;
239 {
240 EventChannel channel(&messenger, channel_name, &codec);
241 auto handler = std::make_unique<StreamHandlerFunctions<>>(
242 [&on_listen_called](const EncodableValue* arguments,
243 std::unique_ptr<EventSink<>>&& events)
244 -> std::unique_ptr<StreamHandlerError<>> {
245 on_listen_called = true;
246 return nullptr;
247 },
248 [&on_cancel_called](const EncodableValue* arguments)
249 -> std::unique_ptr<StreamHandlerError<>> {
250 on_cancel_called = true;
251 return nullptr;
252 });
253 channel.SetStreamHandler(std::move(handler));
254 }
255
256 // The event channel was destroyed but the handler should still be alive.
257 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
258 EXPECT_NE(messenger.last_message_handler(), nullptr);
259
260 // Send test listen message.
261 MethodCall<> call_listen("listen", nullptr);
262 auto message = codec.EncodeMethodCall(call_listen);
263 messenger.last_message_handler()(
264 message->data(), message->size(),
265 [](const uint8_t* reply, const size_t reply_size) {});
266 EXPECT_EQ(on_listen_called, true);
267
268 // Send test cancel message.
269 MethodCall<> call_cancel("cancel", nullptr);
270 message = codec.EncodeMethodCall(call_cancel);
271 messenger.last_message_handler()(
272 message->data(), message->size(),
273 [](const uint8_t* reply, const size_t reply_size) {});
274 EXPECT_EQ(on_cancel_called, true);
275 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), message, and flutter::EventChannel< T >::SetStreamHandler().

## ◆ TEST() [24/291]

flutter::TEST | ( | EventChannelTest | ,
|  | ListenNotCancel |
| ) |  |

Definition at line 146 of file event_channel_unittests.cc.

146 {
147 TestBinaryMessenger messenger;
148 const std::string channel_name("some_channel");
149 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
150 EventChannel channel(&messenger, channel_name, &codec);
151
152 bool on_listen_called = false;
153 bool on_cancel_called = false;
154 auto handler = std::make_unique<StreamHandlerFunctions<>>(
155 [&on_listen_called](const EncodableValue* arguments,
156 std::unique_ptr<EventSink<>>&& events)
157 -> std::unique_ptr<StreamHandlerError<>> {
158 on_listen_called = true;
159 return nullptr;
160 },
161 [&on_cancel_called](const EncodableValue* arguments)
162 -> std::unique_ptr<StreamHandlerError<>> {
163 on_cancel_called = true;
164 return nullptr;
165 });
166 channel.SetStreamHandler(std::move(handler));
167 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
168 EXPECT_NE(messenger.last_message_handler(), nullptr);
169
170 // Send test listen message.
171 MethodCall<> call_listen("listen", nullptr);
172 auto message = codec.EncodeMethodCall(call_listen);
173 messenger.last_message_handler()(
174 message->data(), message->size(),
175 [](const uint8_t* reply, const size_t reply_size) {});
176
177 // Check results.
178 EXPECT_EQ(on_listen_called, true);
179 EXPECT_EQ(on_cancel_called, false);
180 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), message, and flutter::EventChannel< T >::SetStreamHandler().

## ◆ TEST() [25/291]

flutter::TEST | ( | EventChannelTest | ,
|  | Registration |
| ) |  |

Definition at line 49 of file event_channel_unittests.cc.

49 {
50 TestBinaryMessenger messenger;
51 const std::string channel_name("some_channel");
52 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
53 EventChannel channel(&messenger, channel_name, &codec);
54
55 bool on_listen_called = false;
56 auto handler = std::make_unique<StreamHandlerFunctions<>>(
57 [&on_listen_called](const EncodableValue* arguments,
58 std::unique_ptr<EventSink<>>&& events)
59 -> std::unique_ptr<StreamHandlerError<>> {
60 on_listen_called = true;
61 return nullptr;
62 },
63 [](const EncodableValue* arguments)
64 -> std::unique_ptr<StreamHandlerError<>> { return nullptr; });
65 channel.SetStreamHandler(std::move(handler));
66 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
67 EXPECT_NE(messenger.last_message_handler(), nullptr);
68
69 // Send test listen message.
70 MethodCall<> call("listen", nullptr);
71 auto message = codec.EncodeMethodCall(call);
72 messenger.last_message_handler()(
73 message->data(), message->size(),
74 [](const uint8_t* reply, const size_t reply_size) {});
75
76 // Check results.
77 EXPECT_EQ(on_listen_called, true);
78 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), message, and flutter::EventChannel< T >::SetStreamHandler().

## ◆ TEST() [26/291]

flutter::TEST | ( | EventChannelTest | ,
|  | ReRegistration |
| ) |  |

Definition at line 186 of file event_channel_unittests.cc.

186 {
187 TestBinaryMessenger messenger;
188 const std::string channel_name("some_channel");
189 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
190 EventChannel channel(&messenger, channel_name, &codec);
191
192 bool on_listen_called = false;
193 bool on_cancel_called = false;
194 auto handler = std::make_unique<StreamHandlerFunctions<>>(
195 [&on_listen_called](const EncodableValue* arguments,
196 std::unique_ptr<EventSink<>>&& events)
197 -> std::unique_ptr<StreamHandlerError<>> {
198 on_listen_called = true;
199 return nullptr;
200 },
201 [&on_cancel_called](const EncodableValue* arguments)
202 -> std::unique_ptr<StreamHandlerError<>> {
203 on_cancel_called = true;
204 return nullptr;
205 });
206 channel.SetStreamHandler(std::move(handler));
207 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
208 EXPECT_NE(messenger.last_message_handler(), nullptr);
209
210 // Send test listen message.
211 MethodCall<> call("listen", nullptr);
212 auto message = codec.EncodeMethodCall(call);
213 messenger.last_message_handler()(
214 message->data(), message->size(),
215 [](const uint8_t* reply, const size_t reply_size) {});
216 EXPECT_EQ(on_listen_called, true);
217
218 // Send second test message to test StreamHandler's OnCancel
219 // method is called before OnListen method is called.
220 on_listen_called = false;
221 message = codec.EncodeMethodCall(call);
222 messenger.last_message_handler()(
223 message->data(), message->size(),
224 [](const uint8_t* reply, const size_t reply_size) {});
225
226 // Check results.
227 EXPECT_EQ(on_cancel_called, true);
228 EXPECT_EQ(on_listen_called, true);
229 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), message, and flutter::EventChannel< T >::SetStreamHandler().

## ◆ TEST() [27/291]

flutter::TEST | ( | EventChannelTest | ,
|  | StreamHandlerErrorNullptr |
| ) |  |

Definition at line 295 of file event_channel_unittests.cc.

295 {
296 std::unique_ptr<StreamHandlerError<>> error =
297 std::make_unique<StreamHandlerError<>>("Code", "Message", nullptr);
298
299 ASSERT_NE(error.get(), nullptr);
300 EXPECT_FALSE(error->error_details);
301 }
error
const uint8_t uint32_t uint32_t GError ** error
Definition: fl_pixel_buffer_texture_test.cc:40

References error.

## ◆ TEST() [28/291]

flutter::TEST | ( | EventChannelTest | ,
|  | StreamHandlerErrorPassByValue |
| ) |  |

Definition at line 277 of file event_channel_unittests.cc.

277 {
278 std::unique_ptr<StreamHandlerError<>> error = nullptr;
279
280 {
281 std::string code = "Code";
282 std::string msg = "Message";
283 std::unique_ptr<EncodableValue> details =
284 std::make_unique<EncodableValue>("Details");
285 error =
286 std::make_unique<StreamHandlerError<>>(code, msg, std::move(details));
287 }
288
289 ASSERT_NE(error.get(), nullptr);
290 EXPECT_EQ(error->error_code, "Code");
291 EXPECT_EQ(error->error_message, "Message");
292 EXPECT_EQ(std::get<std::string>(*error->error_details), "Details");
293 }

References error.

## ◆ TEST() [29/291]

flutter::TEST | ( | EventChannelTest | ,
|  | Unregistration |
| ) |  |

Definition at line 81 of file event_channel_unittests.cc.

81 {
82 TestBinaryMessenger messenger;
83 const std::string channel_name("some_channel");
84 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
85 EventChannel channel(&messenger, channel_name, &codec);
86
87 auto handler = std::make_unique<StreamHandlerFunctions<>>(
88 [](const EncodableValue* arguments, std::unique_ptr<EventSink<>>&& events)
89 -> std::unique_ptr<StreamHandlerError<>> { return nullptr; },
90 [](const EncodableValue* arguments)
91 -> std::unique_ptr<StreamHandlerError<>> { return nullptr; });
92 channel.SetStreamHandler(std::move(handler));
93 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
94 EXPECT_NE(messenger.last_message_handler(), nullptr);
95
96 channel.SetStreamHandler(nullptr);
97 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
98 EXPECT_EQ(messenger.last_message_handler(), nullptr);
99 }

References flutter::StandardMethodCodec::GetInstance(), and flutter::EventChannel< T >::SetStreamHandler().

## ◆ TEST() [30/291]

flutter::TEST | ( | FlutterProjectBundle | ,
|  | Switches |
| ) |  |

Definition at line 50 of file engine_switches_unittests.cc.

50 {
51 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCHES", "2");
52 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_1", "abc");
53 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"");
54
55 std::vector<std::string> switches = GetSwitchesFromEnvironment();
56 EXPECT_EQ(switches.size(), 2U);
57 EXPECT_EQ(switches[0], "--abc");
58 EXPECT_EQ(switches[1], "--foo=\"bar, baz\"");
59 }
flutter::GetSwitchesFromEnvironment
std::vector< std::string > GetSwitchesFromEnvironment()
Definition: engine_switches.cc:14

References GetSwitchesFromEnvironment().

## ◆ TEST() [31/291]

flutter::TEST | ( | FlutterProjectBundle | ,
|  | SwitchesEmpty |
| ) |  |

Definition at line 31 of file engine_switches_unittests.cc.

31 {
32 // Clear the main environment variable, since test order is not guaranteed.
33 ClearEnvironmentVariable("FLUTTER_ENGINE_SWITCHES");
34
35 EXPECT_EQ(GetSwitchesFromEnvironment().size(), 0U);
36 }

References GetSwitchesFromEnvironment().

## ◆ TEST() [32/291]

flutter::TEST | ( | FlutterProjectBundle | ,
|  | SwitchesExtraValues |
| ) |  |

Definition at line 61 of file engine_switches_unittests.cc.

61 {
62 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCHES", "1");
63 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_1", "abc");
64 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"");
65
66 std::vector<std::string> switches = GetSwitchesFromEnvironment();
67 EXPECT_EQ(switches.size(), 1U);
68 EXPECT_EQ(switches[0], "--abc");
69 }

References GetSwitchesFromEnvironment().

## ◆ TEST() [33/291]

flutter::TEST | ( | FlutterProjectBundle | ,
|  | SwitchesMissingValues |
| ) |  |

Definition at line 71 of file engine_switches_unittests.cc.

71 {
72 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCHES", "4");
73 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_1", "abc");
74 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"");
75 ClearEnvironmentVariable("FLUTTER_ENGINE_SWITCH_3");
76 SetEnvironmentVariable("FLUTTER_ENGINE_SWITCH_4", "oops");
77
78 std::vector<std::string> switches = GetSwitchesFromEnvironment();
79 EXPECT_EQ(switches.size(), 3U);
80 EXPECT_EQ(switches[0], "--abc");
81 EXPECT_EQ(switches[1], "--foo=\"bar, baz\"");
82 // The missing switch should be skipped, leaving SWITCH_4 as the third
83 // switch in the array.
84 EXPECT_EQ(switches[2], "--oops");
85 }

References GetSwitchesFromEnvironment().

## ◆ TEST() [34/291]

flutter::TEST | ( | IncomingMessageDispatcher | ,
|  | BlockInputFalse |
| ) |  |

Definition at line 39 of file incoming_message_dispatcher_unittests.cc.

39 {
40 FlutterDesktopMessengerRef messenger = nullptr;
41 auto dispatcher = std::make_unique<IncomingMessageDispatcher>(messenger);
42 bool did_call[3] = {false, false, false};
43 dispatcher->SetMessageCallback(
44 "hello",
45 [](FlutterDesktopMessengerRef messenger,
46 const FlutterDesktopMessage* message,
47 void* user_data) { reinterpret_cast<bool*>(user_data)[0] = true; },
48 &did_call);
49 FlutterDesktopMessage message = {
50 .struct_size = sizeof(FlutterDesktopMessage),
51 .channel = "hello",
52 .message = nullptr,
53 .message_size = 0,
54 .response_handle = nullptr,
55 };
56 dispatcher->HandleMessage(
57 message, [&did_call] { did_call[1] = true; },
58 [&did_call] { did_call[2] = true; });
59 EXPECT_TRUE(did_call[0]);
60 EXPECT_FALSE(did_call[1]);
61 EXPECT_FALSE(did_call[2]);
62 }
user_data
const char FlTextDirection FlAssertiveness gpointer user_data
Definition: fl_accessibility_handler.cc:24
FlutterDesktopMessengerRef
struct FlutterDesktopMessenger * FlutterDesktopMessengerRef
Definition: flutter_messenger.h:19
FlutterDesktopMessage
Definition: flutter_messenger.h:31

References message, and user_data.

## ◆ TEST() [35/291]

flutter::TEST | ( | IncomingMessageDispatcher | ,
|  | BlockInputTrue |
| ) |  |

Definition at line 64 of file incoming_message_dispatcher_unittests.cc.

64 {
65 FlutterDesktopMessengerRef messenger = nullptr;
66 auto dispatcher = std::make_unique<IncomingMessageDispatcher>(messenger);
67 static int counter = 0;
68 int did_call[3] = {-1, -1, -1};
69 dispatcher->EnableInputBlockingForChannel("hello");
70 dispatcher->SetMessageCallback(
71 "hello",
72 [](FlutterDesktopMessengerRef messenger,
73 const FlutterDesktopMessage* message,
74 void* user_data) { reinterpret_cast<int*>(user_data)[counter++] = 1; },
75 &did_call);
76 FlutterDesktopMessage message = {
77 .struct_size = sizeof(FlutterDesktopMessage),
78 .channel = "hello",
79 .message = nullptr,
80 .message_size = 0,
81 .response_handle = nullptr,
82 };
83 dispatcher->HandleMessage(
84 message, [&did_call] { did_call[counter++] = 0; },
85 [&did_call] { did_call[counter++] = 2; });
86 EXPECT_EQ(did_call[0], 0);
87 EXPECT_EQ(did_call[1], 1);
88 EXPECT_EQ(did_call[2], 2);
89 }

References message, and user_data.

## ◆ TEST() [36/291]

flutter::TEST | ( | IncomingMessageDispatcher | ,
|  | SetHandle |
| ) |  |

Definition at line 10 of file incoming_message_dispatcher_unittests.cc.

10 {
11 FlutterDesktopMessengerRef messenger =
12 reinterpret_cast<FlutterDesktopMessengerRef>(0xfeedface);
13 const uint8_t* message_data = reinterpret_cast<const uint8_t*>(0xcafebabe);
14 auto dispatcher = std::make_unique<IncomingMessageDispatcher>(messenger);
15 bool did_call = false;
16 dispatcher->SetMessageCallback(
17 "hello",
18 [](FlutterDesktopMessengerRef messenger,
19 const FlutterDesktopMessage* message, void* user_data) {
20 EXPECT_EQ(messenger,
21 reinterpret_cast<FlutterDesktopMessengerRef>(0xfeedface));
22 EXPECT_EQ(message->message,
23 reinterpret_cast<const uint8_t*>(0xcafebabe));
24 EXPECT_EQ(message->message_size, 123u);
25 *reinterpret_cast<bool*>(user_data) = true;
26 },
27 &did_call);
28 FlutterDesktopMessage message = {
29 .struct_size = sizeof(FlutterDesktopMessage),
30 .channel = "hello",
31 .message = message_data,
32 .message_size = 123,
33 .response_handle = nullptr,
34 };
35 dispatcher->HandleMessage(message);
36 EXPECT_TRUE(did_call);
37 }

References message, and user_data.

## ◆ TEST() [37/291]

flutter::TEST | ( | JsonMessageCodec | ,
|  | EncodeDecode |
| ) |  |

Definition at line 29 of file json_message_codec_unittests.cc.

29 {
30 // NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
31 rapidjson::Document array(rapidjson::kArrayType);
32 auto& allocator = array.GetAllocator();
33
34 array.PushBack("string", allocator);
35
36 rapidjson::Value map(rapidjson::kObjectType);
37 map.AddMember("a", -7, allocator);
38 map.AddMember("b", std::numeric_limits<int>::max(), allocator);
39 map.AddMember("c", 3.14159, allocator);
40 map.AddMember("d", true, allocator);
41 map.AddMember("e", rapidjson::Value(), allocator);
42 array.PushBack(map, allocator);
43
44 CheckEncodeDecode(array);
45 }
flutter::CheckEncodeDecode
static void CheckEncodeDecode(const EncodableValue &value, const std::vector< uint8_t > &expected_encoding, const StandardCodecSerializer *serializer=nullptr, const std::function< bool(const EncodableValue &a, const EncodableValue &b)> &custom_comparator=nullptr)
Definition: standard_message_codec_unittests.cc:37

References CheckEncodeDecode().

## ◆ TEST() [38/291]

flutter::TEST | ( | JsonMethodCodec | ,
|  | HandlesErrorEnvelopesWithDetails |
| ) |  |

Definition at line 125 of file json_method_codec_unittests.cc.

125 {
126 const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
127 // NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
128 rapidjson::Document details(rapidjson::kArrayType);
129 auto& allocator = details.GetAllocator();
130 details.PushBack("a", allocator);
131 details.PushBack(42, allocator);
132 auto encoded =
133 codec.EncodeErrorEnvelope("errorCode", "something failed", &details);
134 ASSERT_NE(encoded.get(), nullptr);
135 std::vector<uint8_t> bytes = {
136 '[', '"', 'e', 'r', 'r', 'o', 'r', 'C', 'o', 'd', 'e', '"', ',', '"',
137 's', 'o', 'm', 'e', 't', 'h', 'i', 'n', 'g', ' ', 'f', 'a', 'i', 'l',
138 'e', 'd', '"', ',', '[', '"', 'a', '"', ',', '4', '2', ']', ']',
139 };
140 EXPECT_EQ(*encoded, bytes);
141
142 bool decoded_successfully = false;
143 MethodResultFunctions<rapidjson::Document> result_handler(
144 nullptr,
145 [&decoded_successfully](const std::string& code,
146 const std::string& message,
147 const rapidjson::Document* details) {
148 decoded_successfully = true;
149 EXPECT_EQ(code, "errorCode");
150 EXPECT_EQ(message, "something failed");
151 EXPECT_TRUE(details->IsArray());
152 EXPECT_EQ(std::string((*details)[0].GetString()), "a");
153 EXPECT_EQ((*details)[1].GetInt(), 42);
154 },
155 nullptr);
156 codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
157 &result_handler);
158 EXPECT_TRUE(decoded_successfully);
159 }

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::JsonMethodCodec::GetInstance(), and message.

## ◆ TEST() [39/291]

flutter::TEST | ( | JsonMethodCodec | ,
|  | HandlesErrorEnvelopesWithNulls |
| ) |  |

Definition at line 98 of file json_method_codec_unittests.cc.

98 {
99 const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
100 auto encoded = codec.EncodeErrorEnvelope("errorCode");
101 ASSERT_TRUE(encoded);
102 std::vector<uint8_t> bytes = {
103 '[', '"', 'e', 'r', 'r', 'o', 'r', 'C', 'o', 'd', 'e',
104 '"', ',', '"', '"', ',', 'n', 'u', 'l', 'l', ']',
105 };
106 EXPECT_EQ(*encoded, bytes);
107
108 bool decoded_successfully = false;
109 MethodResultFunctions<rapidjson::Document> result_handler(
110 nullptr,
111 [&decoded_successfully](const std::string& code,
112 const std::string& message,
113 const rapidjson::Document* details) {
114 decoded_successfully = true;
115 EXPECT_EQ(code, "errorCode");
116 EXPECT_EQ(message, "");
117 EXPECT_EQ(details, nullptr);
118 },
119 nullptr);
120 codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
121 &result_handler);
122 EXPECT_TRUE(decoded_successfully);
123 }

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::JsonMethodCodec::GetInstance(), and message.

## ◆ TEST() [40/291]

flutter::TEST | ( | JsonMethodCodec | ,
|  | HandlesMethodCallsWithArgument |
| ) |  |

Definition at line 42 of file json_method_codec_unittests.cc.

42 {
43 const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
44
45 auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
46 auto& allocator = arguments->GetAllocator();
47 arguments->PushBack(42, allocator);
48 arguments->PushBack("world", allocator);
49 MethodCall<rapidjson::Document> call("hello", std::move(arguments));
50 auto encoded = codec.EncodeMethodCall(call);
51 ASSERT_TRUE(encoded);
52 std::unique_ptr<MethodCall<rapidjson::Document>> decoded =
53 codec.DecodeMethodCall(*encoded);
54 ASSERT_TRUE(decoded);
55 EXPECT_TRUE(MethodCallsAreEqual(call, *decoded));
56 }

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::JsonMethodCodec::GetInstance().

## ◆ TEST() [41/291]

flutter::TEST | ( | JsonMethodCodec | ,
|  | HandlesMethodCallsWithNullArguments |
| ) |  |

Definition at line 31 of file json_method_codec_unittests.cc.

31 {
32 const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
33 MethodCall<rapidjson::Document> call("hello", nullptr);
34 auto encoded = codec.EncodeMethodCall(call);
35 ASSERT_TRUE(encoded);
36 std::unique_ptr<MethodCall<rapidjson::Document>> decoded =
37 codec.DecodeMethodCall(*encoded);
38 ASSERT_TRUE(decoded);
39 EXPECT_TRUE(MethodCallsAreEqual(call, *decoded));
40 }

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::JsonMethodCodec::GetInstance().

## ◆ TEST() [42/291]

flutter::TEST | ( | JsonMethodCodec | ,
|  | HandlesSuccessEnvelopesWithNullResult |
| ) |  |

Definition at line 58 of file json_method_codec_unittests.cc.

58 {
59 const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
60 auto encoded = codec.EncodeSuccessEnvelope();
61 ASSERT_TRUE(encoded);
62 std::vector<uint8_t> bytes = {'[', 'n', 'u', 'l', 'l', ']'};
63 EXPECT_EQ(*encoded, bytes);
64
65 bool decoded_successfully = false;
66 MethodResultFunctions<rapidjson::Document> result_handler(
67 [&decoded_successfully](const rapidjson::Document* result) {
68 decoded_successfully = true;
69 EXPECT_EQ(result, nullptr);
70 },
71 nullptr, nullptr);
72 codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
73 &result_handler);
74 EXPECT_TRUE(decoded_successfully);
75 }

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::JsonMethodCodec::GetInstance().

## ◆ TEST() [43/291]

flutter::TEST | ( | JsonMethodCodec | ,
|  | HandlesSuccessEnvelopesWithResult |
| ) |  |

Definition at line 77 of file json_method_codec_unittests.cc.

77 {
78 const JsonMethodCodec& codec = JsonMethodCodec::GetInstance();
79 rapidjson::Document result;
80 result.SetInt(42);
81 auto encoded = codec.EncodeSuccessEnvelope(&result);
82 ASSERT_TRUE(encoded);
83 std::vector<uint8_t> bytes = {'[', '4', '2', ']'};
84 EXPECT_EQ(*encoded, bytes);
85
86 bool decoded_successfully = false;
87 MethodResultFunctions<rapidjson::Document> result_handler(
88 [&decoded_successfully](const rapidjson::Document* result) {
89 decoded_successfully = true;
90 EXPECT_EQ(result->GetInt(), 42);
91 },
92 nullptr, nullptr);
93 codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
94 &result_handler);
95 EXPECT_TRUE(decoded_successfully);
96 }

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::JsonMethodCodec::GetInstance().

## ◆ TEST() [44/291]

flutter::TEST | ( | MethodCallTest | ,
|  | Basic |
| ) |  |

Definition at line 14 of file method_call_unittests.cc.

14 {
15 const std::string method_name("method_name");
16 const int argument = 42;
17 MethodCall<int> method_call(method_name, std::make_unique<int>(argument));
18 EXPECT_EQ(method_call.method_name(), method_name);
19 ASSERT_NE(method_call.arguments(), nullptr);
20 EXPECT_EQ(*method_call.arguments(), 42);
21 }
method_call
G_BEGIN_DECLS G_MODULE_EXPORT FlMethodCall * method_call
Definition: fl_method_channel.h:120

References method_call.

## ◆ TEST() [45/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | Error |
| ) |  |

Definition at line 37 of file method_result_functions_unittests.cc.

37 {
38 bool called = false;
39 std::string error_code = "a";
40 std::string error_message = "b";
41 int error_details = 1;
42 MethodResultFunctions<int> result(
43 nullptr,
44 [&called, error_code, error_message, error_details](
45 const std::string& code, const std::string& message,
46 const int* details) {
47 called = true;
48 EXPECT_EQ(code, error_code);
49 EXPECT_EQ(message, error_message);
50 EXPECT_EQ(*details, error_details);
51 },
52 nullptr);
53 result.Error(error_code, error_message, error_details);
54 EXPECT_TRUE(called);
55 }

References flutter::MethodResult< T >::Error(), and message.

## ◆ TEST() [46/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | InvokeNotImplemented |
| ) |  |

Definition at line 145 of file method_channel_unittests.cc.

145 {
146 TestBinaryMessenger messenger;
147 const std::string channel_name("some_channel");
148 MethodChannel channel(&messenger, channel_name,
149 &StandardMethodCodec::GetInstance());
150
151 bool received_not_implemented = false;
152 auto result_handler = std::make_unique<MethodResultFunctions<>>(
153 nullptr, nullptr,
154 [&received_not_implemented]() { received_not_implemented = true; });
155
156 channel.InvokeMethod("foo", nullptr, std::move(result_handler));
157 EXPECT_EQ(messenger.send_called(), true);
158 ASSERT_NE(messenger.last_reply_handler(), nullptr);
159
160 // Call the underlying reply handler to ensure it's reported as unimplemented.
161 messenger.last_reply_handler()(nullptr, 0);
162 EXPECT_TRUE(received_not_implemented);
163 }

References flutter::StandardMethodCodec::GetInstance(), and flutter::MethodChannel< T >::InvokeMethod().

## ◆ TEST() [47/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | InvokeWithoutResponse |
| ) |  |

Definition at line 107 of file method_channel_unittests.cc.

107 {
108 TestBinaryMessenger messenger;
109 const std::string channel_name("some_channel");
110 MethodChannel channel(&messenger, channel_name,
111 &StandardMethodCodec::GetInstance());
112
113 channel.InvokeMethod("foo", nullptr);
114 EXPECT_TRUE(messenger.send_called());
115 EXPECT_EQ(messenger.last_reply_handler(), nullptr);
116 }

References flutter::StandardMethodCodec::GetInstance(), and flutter::MethodChannel< T >::InvokeMethod().

## ◆ TEST() [48/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | InvokeWithResponse |
| ) |  |

Definition at line 118 of file method_channel_unittests.cc.

118 {
119 TestBinaryMessenger messenger;
120 const std::string channel_name("some_channel");
121 MethodChannel channel(&messenger, channel_name,
122 &StandardMethodCodec::GetInstance());
123
124 bool received_reply = false;
125 const std::string reply = "bar";
126 auto result_handler = std::make_unique<MethodResultFunctions<>>(
127 [&received_reply, reply](const EncodableValue* success_value) {
128 received_reply = true;
129 EXPECT_EQ(std::get<std::string>(*success_value), reply);
130 },
131 nullptr, nullptr);
132
133 channel.InvokeMethod("foo", nullptr, std::move(result_handler));
134 EXPECT_TRUE(messenger.send_called());
135 ASSERT_NE(messenger.last_reply_handler(), nullptr);
136
137 // Call the underlying reply handler to ensure it's processed correctly.
138 EncodableValue reply_value(reply);
139 std::unique_ptr<std::vector<uint8_t>> encoded_reply =
140 StandardMethodCodec::GetInstance().EncodeSuccessEnvelope(&reply_value);
141 messenger.last_reply_handler()(encoded_reply->data(), encoded_reply->size());
142 EXPECT_TRUE(received_reply);
143 }

References flutter::MethodCodec< T >::EncodeSuccessEnvelope(), flutter::StandardMethodCodec::GetInstance(), and flutter::MethodChannel< T >::InvokeMethod().

## ◆ TEST() [49/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | NoHandlers |
| ) |  |

Definition at line 15 of file method_result_functions_unittests.cc.

15 {
16 MethodResultFunctions<int> result(nullptr, nullptr, nullptr);
17 result.Success();
18 result.Error("error");
19 result.NotImplemented();
20 }

References flutter::MethodResult< T >::Error(), flutter::MethodResult< T >::NotImplemented(), and flutter::MethodResult< T >::Success().

## ◆ TEST() [50/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | NotImplemented |
| ) |  |

Definition at line 58 of file method_result_functions_unittests.cc.

58 {
59 bool called = false;
60 MethodResultFunctions<int> result(nullptr, nullptr,
61 [&called]() { called = true; });
62 result.NotImplemented();
63 EXPECT_TRUE(called);
64 }

References flutter::MethodResult< T >::NotImplemented().

## ◆ TEST() [51/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | Registration |
| ) |  |

Definition at line 62 of file method_channel_unittests.cc.

62 {
63 TestBinaryMessenger messenger;
64 const std::string channel_name("some_channel");
65 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
66 MethodChannel channel(&messenger, channel_name, &codec);
67
68 bool callback_called = false;
69 const std::string method_name("hello");
70 channel.SetMethodCallHandler(
71 [&callback_called, method_name](const auto& call, auto result) {
72 callback_called = true;
73 // Ensure that the wrapper received a correctly decoded call and a
74 // result.
75 EXPECT_EQ(call.method_name(), method_name);
76 EXPECT_NE(result, nullptr);
77 result->Success();
78 });
79 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
80 EXPECT_NE(messenger.last_message_handler(), nullptr);
81 // Send a test message to trigger the handler test assertions.
82 MethodCall<> call(method_name, nullptr);
83 auto message = codec.EncodeMethodCall(call);
84
85 messenger.last_message_handler()(
86 message->data(), message->size(),
87 [](const uint8_t* reply, size_t reply_size) {});
88 EXPECT_TRUE(callback_called);
89 }

References flutter::MethodCodec< T >::EncodeMethodCall(), flutter::StandardMethodCodec::GetInstance(), message, and flutter::MethodChannel< T >::SetMethodCallHandler().

## ◆ TEST() [52/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | Resize |
| ) |  |

Definition at line 167 of file method_channel_unittests.cc.

167 {
168 TestBinaryMessenger messenger;
169 const std::string channel_name("flutter/test");
170 MethodChannel channel(&messenger, channel_name,
171 &StandardMethodCodec::GetInstance());
172
173 channel.Resize(3);
174
175 // Because the Dart implementation for the control channel implements its own
176 // custom deserialization logic, this test compares the generated bytes array
177 // to the expected one (for instance, the deserialization logic expects the
178 // size parameter of the resize method call to be an uint32).
179 //
180 // The expected content was created from the following Dart code:
181 // MethodCall call = MethodCall('resize', ['flutter/test',3]);
182 // StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
183 const int expected_message_size = 29;
184
185 EXPECT_EQ(messenger.send_called(), true);
186 EXPECT_EQ(static_cast<int>(messenger.last_message().size()),
187 expected_message_size);
188
189 int expected[expected_message_size] = {
190 7, 6, 114, 101, 115, 105, 122, 101, 12, 2, 7, 12, 102, 108, 117,
191 116, 116, 101, 114, 47, 116, 101, 115, 116, 3, 3, 0, 0, 0};
192 for (int i = 0; i < expected_message_size; i++) {
193 EXPECT_EQ(messenger.last_message()[i], expected[i]);
194 }
195 }

References flutter::StandardMethodCodec::GetInstance(), i, and flutter::MethodChannel< T >::Resize().

## ◆ TEST() [53/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | SetWarnsOnOverflow |
| ) |  |

Definition at line 199 of file method_channel_unittests.cc.

199 {
200 TestBinaryMessenger messenger;
201
202 const std::string channel_name("flutter/test");
203 MethodChannel channel(&messenger, channel_name,
204 &StandardMethodCodec::GetInstance());
205
206 channel.SetWarnsOnOverflow(false);
207
208 // The expected content was created from the following Dart code:
209 // MethodCall call = MethodCall('overflow',['flutter/test', true]);
210 // StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
211 const int expected_message_size = 27;
212
213 EXPECT_EQ(messenger.send_called(), true);
214 EXPECT_EQ(static_cast<int>(messenger.last_message().size()),
215 expected_message_size);
216
217 int expected[expected_message_size] = {
218 7, 8, 111, 118, 101, 114, 102, 108, 111, 119, 12, 2, 7, 12,
219 102, 108, 117, 116, 116, 101, 114, 47, 116, 101, 115, 116, 1};
220 for (int i = 0; i < expected_message_size; i++) {
221 EXPECT_EQ(messenger.last_message()[i], expected[i]);
222 }
223 }

References flutter::StandardMethodCodec::GetInstance(), i, and flutter::MethodChannel< T >::SetWarnsOnOverflow().

## ◆ TEST() [54/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | Success |
| ) |  |

Definition at line 23 of file method_result_functions_unittests.cc.

23 {
24 bool called = false;
25 int value = 1;
26 MethodResultFunctions<int> result(
27 [&called, value](const int* i) {
28 called = true;
29 EXPECT_EQ(*i, value);
30 },
31 nullptr, nullptr);
32 result.Success(value);
33 EXPECT_TRUE(called);
34 }

References i, flutter::MethodResult< T >::Success(), and value.

## ◆ TEST() [55/291]

flutter::TEST | ( | MethodChannelTest | ,
|  | Unregistration |
| ) |  |

Definition at line 92 of file method_channel_unittests.cc.

92 {
93 TestBinaryMessenger messenger;
94 const std::string channel_name("some_channel");
95 MethodChannel channel(&messenger, channel_name,
96 &StandardMethodCodec::GetInstance());
97
98 channel.SetMethodCallHandler([](const auto& call, auto result) {});
99 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
100 EXPECT_NE(messenger.last_message_handler(), nullptr);
101
102 channel.SetMethodCallHandler(nullptr);
103 EXPECT_EQ(messenger.last_message_handler_channel(), channel_name);
104 EXPECT_EQ(messenger.last_message_handler(), nullptr);
105 }

References flutter::StandardMethodCodec::GetInstance(), and flutter::MethodChannel< T >::SetMethodCallHandler().

## ◆ TEST() [56/291]

flutter::TEST | ( | PathUtilsTest | ,
|  | ExecutableDirector |
| ) |  |

Definition at line 12 of file path_utils_unittests.cc.

12 {
13 std::filesystem::path exe_directory = GetExecutableDirectory();
14 #if defined(__linux__) || defined(_WIN32)
15 EXPECT_EQ(exe_directory.empty(), false);
16 EXPECT_EQ(exe_directory.is_absolute(), true);
17 #else
18 // On platforms where it's not implemented, it should indicate that
19 // by returning an empty path.
20 EXPECT_EQ(exe_directory.empty(), true);
21 #endif
22 }
flutter::GetExecutableDirectory
std::filesystem::path GetExecutableDirectory()
Definition: path_utils.cc:16

References GetExecutableDirectory().

## ◆ TEST() [57/291]

flutter::TEST | ( | PluginRegistrarTest | ,
|  | ManagerDifferentInstances |
| ) |  |

Definition at line 175 of file plugin_registrar_unittests.cc.

175 {
176 PluginRegistrarManager* manager = PluginRegistrarManager::GetInstance();
177 manager->Reset();
178
179 testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
180
181 auto dummy_registrar_handle_a =
182 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
183 auto dummy_registrar_handle_b =
184 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(2);
185
186 EXPECT_NE(manager->GetRegistrar<PluginRegistrar>(dummy_registrar_handle_a),
187 manager->GetRegistrar<PluginRegistrar>(dummy_registrar_handle_b));
188 }
FlutterDesktopPluginRegistrarRef
struct FlutterDesktopPluginRegistrar * FlutterDesktopPluginRegistrarRef
Definition: flutter_plugin_registrar.h:20

References flutter::PluginRegistrarManager::GetInstance(), flutter::PluginRegistrarManager::GetRegistrar(), and flutter::PluginRegistrarManager::Reset().

## ◆ TEST() [58/291]

flutter::TEST | ( | PluginRegistrarTest | ,
|  | ManagerRemovesOnDestruction |
| ) |  |

Definition at line 192 of file plugin_registrar_unittests.cc.

192 {
193 PluginRegistrarManager* manager = PluginRegistrarManager::GetInstance();
194 manager->Reset();
195
196 testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
197 auto test_api = static_cast<TestApi*>(scoped_api_stub.stub());
198
199 auto dummy_registrar_handle =
200 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
201 auto* wrapper =
202 manager->GetRegistrar<TestPluginRegistrar>(dummy_registrar_handle);
203
204 // Simulate destruction of the reference, and ensure that the wrapper
205 // is destroyed.
206 EXPECT_NE(test_api->last_destruction_callback_set(), nullptr);
207 bool destroyed = false;
208 wrapper->SetDestructionCallback([&destroyed]() { destroyed = true; });
209 test_api->last_destruction_callback_set()(dummy_registrar_handle);
210 EXPECT_EQ(destroyed, true);
211
212 // Requesting the wrapper should now create a new object.
213 EXPECT_NE(manager->GetRegistrar<TestPluginRegistrar>(dummy_registrar_handle),
214 nullptr);
215 }

References flutter::PluginRegistrarManager::GetInstance(), flutter::PluginRegistrarManager::GetRegistrar(), and flutter::PluginRegistrarManager::Reset().

## ◆ TEST() [59/291]

flutter::TEST | ( | PluginRegistrarTest | ,
|  | ManagerSameInstance |
| ) |  |

Definition at line 160 of file plugin_registrar_unittests.cc.

160 {
161 PluginRegistrarManager* manager = PluginRegistrarManager::GetInstance();
162 manager->Reset();
163
164 testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
165
166 auto dummy_registrar_handle =
167 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
168
169 EXPECT_EQ(manager->GetRegistrar<PluginRegistrar>(dummy_registrar_handle),
170 manager->GetRegistrar<PluginRegistrar>(dummy_registrar_handle));
171 }

References flutter::PluginRegistrarManager::GetInstance(), flutter::PluginRegistrarManager::GetRegistrar(), and flutter::PluginRegistrarManager::Reset().

## ◆ TEST() [60/291]

flutter::TEST | ( | PluginRegistrarTest | ,
|  | MessengerSend |
| ) |  |

Definition at line 120 of file plugin_registrar_unittests.cc.

120 {
121 testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
122 auto test_api = static_cast<TestApi*>(scoped_api_stub.stub());
123
124 auto dummy_registrar_handle =
125 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
126 PluginRegistrar registrar(dummy_registrar_handle);
127 BinaryMessenger* messenger = registrar.messenger();
128
129 std::vector<uint8_t> message = {1, 2, 3, 4};
130 messenger->Send("some_channel", &message[0], message.size());
131 EXPECT_EQ(test_api->last_data_sent(), &message[0]);
132 }

References message, flutter::PluginRegistrar::messenger(), and flutter::BinaryMessenger::Send().

## ◆ TEST() [61/291]

flutter::TEST | ( | PluginRegistrarTest | ,
|  | MessengerSetMessageHandler |
| ) |  |

Definition at line 136 of file plugin_registrar_unittests.cc.

136 {
137 testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
138 auto test_api = static_cast<TestApi*>(scoped_api_stub.stub());
139
140 auto dummy_registrar_handle =
141 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
142 PluginRegistrar registrar(dummy_registrar_handle);
143 BinaryMessenger* messenger = registrar.messenger();
144 const std::string channel_name("foo");
145
146 // Register.
147 BinaryMessageHandler binary_handler = [](const uint8_t* message,
148 const size_t message_size,
149 const BinaryReply& reply) {};
150 messenger->SetMessageHandler(channel_name, std::move(binary_handler));
151 EXPECT_NE(test_api->last_message_callback_set(), nullptr);
152
153 // Unregister.
154 messenger->SetMessageHandler(channel_name, nullptr);
155 EXPECT_EQ(test_api->last_message_callback_set(), nullptr);
156 }
flutter::BinaryMessageHandler
std::function< void(const uint8_t *message, size_t message_size, BinaryReply reply)> BinaryMessageHandler
Definition: binary_messenger.h:25
flutter::BinaryReply
std::function< void(const uint8_t *reply, size_t reply_size)> BinaryReply
Definition: binary_messenger.h:18

References message, flutter::PluginRegistrar::messenger(), and flutter::BinaryMessenger::SetMessageHandler().

## ◆ TEST() [62/291]

flutter::TEST | ( | PluginRegistrarTest | ,
|  | PluginDestroyedBeforeRegistrar |
| ) |  |

Definition at line 104 of file plugin_registrar_unittests.cc.

104 {
105 auto dummy_registrar_handle =
106 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
107 bool registrar_valid_at_destruction = false;
108 {
109 PluginRegistrar registrar(dummy_registrar_handle);
110
111 auto plugin = std::make_unique<TestPlugin>(&registrar,
112 &registrar_valid_at_destruction);
113 registrar.AddPlugin(std::move(plugin));
114 }
115 EXPECT_TRUE(registrar_valid_at_destruction);
116 }

References flutter::PluginRegistrar::AddPlugin().

## ◆ TEST() [63/291]

flutter::TEST | ( | PluginRegistrarTest | ,
|  | TextureRegistrarNotNull |
| ) |  |

Definition at line 218 of file plugin_registrar_unittests.cc.

218 {
219 auto dummy_registrar_handle =
220 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
221 PluginRegistrar registrar(dummy_registrar_handle);
222
223 TextureRegistrar* texture_registrar = registrar.texture_registrar();
224
225 ASSERT_NE(texture_registrar, nullptr);
226 }

References flutter::PluginRegistrar::texture_registrar().

## ◆ TEST() [64/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanDecodeEmptyBytesAsNullWithoutCallingSerializer |
| ) |  |

Definition at line 95 of file standard_message_codec_unittests.cc.

95 {
96 std::vector<uint8_t> bytes = {};
97 const MockStandardCodecSerializer serializer;
98 const StandardMessageCodec& codec =
99 StandardMessageCodec::GetInstance(&serializer);
100
101 auto decoded = codec.DecodeMessage(bytes);
102
103 EXPECT_EQ(EncodableValue(), *decoded);
104 EXPECT_CALL(serializer, ReadValueOfType(::testing::_, ::testing::_)).Times(0);
105 }

References flutter::MessageCodec< T >::DecodeMessage(), and flutter::StandardMessageCodec::GetInstance().

## ◆ TEST() [65/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeByteArray |
| ) |  |

Definition at line 193 of file standard_message_codec_unittests.cc.

193 {
194 std::vector<uint8_t> bytes = {0x08, 0x04, 0xba, 0x5e, 0xba, 0x11};
195 EncodableValue value(std::vector<uint8_t>{0xba, 0x5e, 0xba, 0x11});
196 CheckEncodeDecode(value, bytes);
197 }

References CheckEncodeDecode(), and value.

## ◆ TEST() [66/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeDouble |
| ) |  |

Definition at line 128 of file standard_message_codec_unittests.cc.

128 {
129 std::vector<uint8_t> bytes = {0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
130 0x18, 0x2d, 0x44, 0x54, 0xfb, 0x21, 0x09, 0x40};
131 CheckEncodeDecode(EncodableValue(3.14159265358979311599796346854), bytes);
132 }

References CheckEncodeDecode().

## ◆ TEST() [67/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeEmptyList |
| ) |  |

Definition at line 175 of file standard_message_codec_unittests.cc.

175 {
176 std::vector<uint8_t> bytes = {0x0c, 0x00};
177 CheckEncodeDecode(EncodableValue(EncodableList{}), bytes);
178 }

References CheckEncodeDecode().

## ◆ TEST() [68/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeEmptyString |
| ) |  |

Definition at line 150 of file standard_message_codec_unittests.cc.

150 {
151 std::vector<uint8_t> bytes = {0x07, 0x00};
152 CheckEncodeDecode(EncodableValue(""), bytes);
153 }

References CheckEncodeDecode().

## ◆ TEST() [69/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeFalse |
| ) |  |

Definition at line 112 of file standard_message_codec_unittests.cc.

112 {
113 std::vector<uint8_t> bytes = {0x02};
114 CheckEncodeDecode(EncodableValue(false), bytes);
115 }

References CheckEncodeDecode().

## ◆ TEST() [70/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeFloat32Array |
| ) |  |

Definition at line 214 of file standard_message_codec_unittests.cc.

214 {
215 std::vector<uint8_t> bytes = {0x0e, 0x02, 0x00, 0x00, 0xd8, 0x0f,
216 0x49, 0x40, 0x00, 0x00, 0x7a, 0x44};
217 EncodableValue value(std::vector<float>{3.1415920257568359375f, 1000.0f});
218 CheckEncodeDecode(value, bytes);
219 }

References CheckEncodeDecode(), and value.

## ◆ TEST() [71/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeFloat64Array |
| ) |  |

Definition at line 221 of file standard_message_codec_unittests.cc.

221 {
222 std::vector<uint8_t> bytes = {0x0b, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
223 0x18, 0x2d, 0x44, 0x54, 0xfb, 0x21, 0x09, 0x40,
224 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x8f, 0x40};
225 EncodableValue value(
226 std::vector<double>{3.14159265358979311599796346854, 1000.0});
227 CheckEncodeDecode(value, bytes);
228 }

References CheckEncodeDecode(), and value.

## ◆ TEST() [72/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeInt32 |
| ) |  |

Definition at line 117 of file standard_message_codec_unittests.cc.

117 {
118 std::vector<uint8_t> bytes = {0x03, 0x78, 0x56, 0x34, 0x12};
119 CheckEncodeDecode(EncodableValue(0x12345678), bytes);
120 }

References CheckEncodeDecode().

## ◆ TEST() [73/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeInt32Array |
| ) |  |

Definition at line 199 of file standard_message_codec_unittests.cc.

199 {
200 std::vector<uint8_t> bytes = {0x09, 0x03, 0x00, 0x00, 0x78, 0x56, 0x34, 0x12,
201 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00};
202 EncodableValue value(std::vector<int32_t>{0x12345678, -1, 0});
203 CheckEncodeDecode(value, bytes);
204 }

References CheckEncodeDecode(), and value.

## ◆ TEST() [74/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeInt64 |
| ) |  |

Definition at line 122 of file standard_message_codec_unittests.cc.

122 {
123 std::vector<uint8_t> bytes = {0x04, 0xef, 0xcd, 0xab, 0x90,
124 0x78, 0x56, 0x34, 0x12};
125 CheckEncodeDecode(EncodableValue(INT64_C(0x1234567890abcdef)), bytes);
126 }

References CheckEncodeDecode().

## ◆ TEST() [75/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeInt64Array |
| ) |  |

Definition at line 206 of file standard_message_codec_unittests.cc.

206 {
207 std::vector<uint8_t> bytes = {0x0a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
208 0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12,
209 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
210 EncodableValue value(std::vector<int64_t>{0x1234567890abcdef, -1});
211 CheckEncodeDecode(value, bytes);
212 }

References CheckEncodeDecode(), and value.

## ◆ TEST() [76/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeList |
| ) |  |

Definition at line 155 of file standard_message_codec_unittests.cc.

155 {
156 std::vector<uint8_t> bytes = {
157 0x0c, 0x05, 0x00, 0x07, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x06,
158 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x85, 0xeb, 0x51, 0xb8, 0x1e,
159 0x09, 0x40, 0x03, 0x2f, 0x00, 0x00, 0x00, 0x0c, 0x02, 0x03, 0x2a,
160 0x00, 0x00, 0x00, 0x07, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64,
161 };
162 EncodableValue value(EncodableList{
163 EncodableValue(),
164 EncodableValue("hello"),
165 EncodableValue(3.14),
166 EncodableValue(47),
167 EncodableValue(EncodableList{
168 EncodableValue(42),
169 EncodableValue("nested"),
170 }),
171 });
172 CheckEncodeDecode(value, bytes);
173 }

References CheckEncodeDecode(), and value.

## ◆ TEST() [77/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeMap |
| ) |  |

Definition at line 180 of file standard_message_codec_unittests.cc.

180 {
181 std::vector<uint8_t> bytes_prefix = {0x0d, 0x04};
182 EncodableValue value(EncodableMap{
183 {EncodableValue("a"), EncodableValue(3.14)},
184 {EncodableValue("b"), EncodableValue(47)},
185 {EncodableValue(), EncodableValue()},
186 {EncodableValue(3.14), EncodableValue(EncodableList{
187 EncodableValue("nested"),
188 })},
189 });
190 CheckEncodeDecodeWithEncodePrefix(value, bytes_prefix, 48);
191 }
flutter::CheckEncodeDecodeWithEncodePrefix
static void CheckEncodeDecodeWithEncodePrefix(const EncodableValue &value, const std::vector< uint8_t > &expected_encoding_prefix, size_t expected_encoding_length)
Definition: standard_message_codec_unittests.cc:62

References CheckEncodeDecodeWithEncodePrefix(), and value.

## ◆ TEST() [78/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeNull |
| ) |  |

Definition at line 90 of file standard_message_codec_unittests.cc.

90 {
91 std::vector<uint8_t> bytes = {0x00};
92 CheckEncodeDecode(EncodableValue(), bytes);
93 }

References CheckEncodeDecode().

## ◆ TEST() [79/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeSimpleCustomType |
| ) |  |

Definition at line 230 of file standard_message_codec_unittests.cc.

230 {
231 std::vector<uint8_t> bytes = {0x80, 0x09, 0x00, 0x00, 0x00,
232 0x10, 0x00, 0x00, 0x00};
233 auto point_comparator = [](const EncodableValue& a, const EncodableValue& b) {
234 const Point& a_point =
235 std::any_cast<Point>(std::get<CustomEncodableValue>(a));
236 const Point& b_point =
237 std::any_cast<Point>(std::get<CustomEncodableValue>(b));
238 return a_point == b_point;
239 };
240 CheckEncodeDecode(CustomEncodableValue(Point(9, 16)), bytes,
241 &PointExtensionSerializer::GetInstance(), point_comparator);
242 }

References CheckEncodeDecode().

## ◆ TEST() [80/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeString |
| ) |  |

Definition at line 134 of file standard_message_codec_unittests.cc.

134 {
135 std::vector<uint8_t> bytes = {0x07, 0x0b, 0x68, 0x65, 0x6c, 0x6c, 0x6f,
136 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64};
137 CheckEncodeDecode(EncodableValue("hello world"), bytes);
138 }

References CheckEncodeDecode().

## ◆ TEST() [81/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeStringWithNonAsciiCodePoint |
| ) |  |

Definition at line 140 of file standard_message_codec_unittests.cc.

140 {
141 std::vector<uint8_t> bytes = {0x07, 0x05, 0x68, 0xe2, 0x98, 0xba, 0x77};
142 CheckEncodeDecode(EncodableValue("h\u263Aw"), bytes);
143 }

References CheckEncodeDecode().

## ◆ TEST() [82/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeStringWithNonBMPCodePoint |
| ) |  |

Definition at line 145 of file standard_message_codec_unittests.cc.

145 {
146 std::vector<uint8_t> bytes = {0x07, 0x06, 0x68, 0xf0, 0x9f, 0x98, 0x82, 0x77};
147 CheckEncodeDecode(EncodableValue("h\U0001F602w"), bytes);
148 }

References CheckEncodeDecode().

## ◆ TEST() [83/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeTrue |
| ) |  |

Definition at line 107 of file standard_message_codec_unittests.cc.

107 {
108 std::vector<uint8_t> bytes = {0x01};
109 CheckEncodeDecode(EncodableValue(true), bytes);
110 }

References CheckEncodeDecode().

## ◆ TEST() [84/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | CanEncodeAndDecodeVariableLengthCustomType |
| ) |  |

Definition at line 244 of file standard_message_codec_unittests.cc.

244 {
245 std::vector<uint8_t> bytes = {
246 0x81, // custom type
247 0x06, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, // data
248 0x07, 0x04, // string type and length
249 0x74, 0x65, 0x73, 0x74 // string characters
250 };
251 auto some_data_comparator = [](const EncodableValue& a,
252 const EncodableValue& b) {
253 const SomeData& data_a =
254 std::any_cast<SomeData>(std::get<CustomEncodableValue>(a));
255 const SomeData& data_b =
256 std::any_cast<SomeData>(std::get<CustomEncodableValue>(b));
257 return data_a.data() == data_b.data() && data_a.label() == data_b.label();
258 };
259 CheckEncodeDecode(CustomEncodableValue(
260 SomeData("test", {0x00, 0x01, 0x02, 0x03, 0x04, 0x05})),
261 bytes, &SomeDataExtensionSerializer::GetInstance(),
262 some_data_comparator);
263 }

References CheckEncodeDecode().

## ◆ TEST() [85/291]

flutter::TEST | ( | StandardMessageCodec | ,
|  | GetInstanceCachesInstance |
| ) |  |

Definition at line 82 of file standard_message_codec_unittests.cc.

82 {
83 const StandardMessageCodec& codec_a =
84 StandardMessageCodec::GetInstance(nullptr);
85 const StandardMessageCodec& codec_b =
86 StandardMessageCodec::GetInstance(nullptr);
87 EXPECT_EQ(&codec_a, &codec_b);
88 }

References flutter::StandardMessageCodec::GetInstance().

## ◆ TEST() [86/291]

flutter::TEST | ( | StandardMethodCodec | ,
|  | GetInstanceCachesInstance |
| ) |  |

Definition at line 35 of file standard_method_codec_unittests.cc.

35 {
36 const StandardMethodCodec& codec_a =
37 StandardMethodCodec::GetInstance(nullptr);
38 const StandardMethodCodec& codec_b =
39 StandardMethodCodec::GetInstance(nullptr);
40 EXPECT_EQ(&codec_a, &codec_b);
41 }

References flutter::StandardMethodCodec::GetInstance().

## ◆ TEST() [87/291]

flutter::TEST | ( | StandardMethodCodec | ,
|  | HandlesCustomTypeArguments |
| ) |  |

Definition at line 167 of file standard_method_codec_unittests.cc.

167 {
168 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance(
169 &PointExtensionSerializer::GetInstance());
170 Point point(7, 9);
171 MethodCall<> call(
172 "hello", std::make_unique<EncodableValue>(CustomEncodableValue(point)));
173 auto encoded = codec.EncodeMethodCall(call);
174 ASSERT_NE(encoded.get(), nullptr);
175 std::unique_ptr<MethodCall<>> decoded = codec.DecodeMethodCall(*encoded);
176 ASSERT_NE(decoded.get(), nullptr);
177
178 const Point& decoded_point = std::any_cast<Point>(
179 std::get<CustomEncodableValue>(*decoded->arguments()));
180 EXPECT_EQ(point, decoded_point);
181 };

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::StandardMethodCodec::GetInstance().

## ◆ TEST() [88/291]

flutter::TEST | ( | StandardMethodCodec | ,
|  | HandlesErrorEnvelopesWithDetails |
| ) |  |

Definition at line 130 of file standard_method_codec_unittests.cc.

130 {
131 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
132 EncodableValue details(EncodableList{
133 EncodableValue("a"),
134 EncodableValue(42),
135 });
136 auto encoded =
137 codec.EncodeErrorEnvelope("errorCode", "something failed", &details);
138 ASSERT_NE(encoded.get(), nullptr);
139 std::vector<uint8_t> bytes = {
140 0x01, 0x07, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f,
141 0x64, 0x65, 0x07, 0x10, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x68,
142 0x69, 0x6e, 0x67, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64,
143 0x0c, 0x02, 0x07, 0x01, 0x61, 0x03, 0x2a, 0x00, 0x00, 0x00,
144 };
145 EXPECT_EQ(*encoded, bytes);
146
147 bool decoded_successfully = false;
148 MethodResultFunctions<> result_handler(
149 nullptr,
150 [&decoded_successfully](const std::string& code,
151 const std::string& message,
152 const EncodableValue* details) {
153 decoded_successfully = true;
154 EXPECT_EQ(code, "errorCode");
155 EXPECT_EQ(message, "something failed");
156 const auto* details_list = std::get_if<EncodableList>(details);
157 ASSERT_NE(details_list, nullptr);
158 EXPECT_EQ(std::get<std::string>((*details_list)[0]), "a");
159 EXPECT_EQ(std::get<int32_t>((*details_list)[1]), 42);
160 },
161 nullptr);
162 codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
163 &result_handler);
164 EXPECT_TRUE(decoded_successfully);
165 }

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::StandardMethodCodec::GetInstance(), and message.

## ◆ TEST() [89/291]

flutter::TEST | ( | StandardMethodCodec | ,
|  | HandlesErrorEnvelopesWithNulls |
| ) |  |

Definition at line 105 of file standard_method_codec_unittests.cc.

105 {
106 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
107 auto encoded = codec.EncodeErrorEnvelope("errorCode");
108 ASSERT_NE(encoded.get(), nullptr);
109 std::vector<uint8_t> bytes = {0x01, 0x07, 0x09, 0x65, 0x72, 0x72, 0x6f,
110 0x72, 0x43, 0x6f, 0x64, 0x65, 0x00, 0x00};
111 EXPECT_EQ(*encoded, bytes);
112
113 bool decoded_successfully = false;
114 MethodResultFunctions<> result_handler(
115 nullptr,
116 [&decoded_successfully](const std::string& code,
117 const std::string& message,
118 const EncodableValue* details) {
119 decoded_successfully = true;
120 EXPECT_EQ(code, "errorCode");
121 EXPECT_EQ(message, "");
122 EXPECT_EQ(details, nullptr);
123 },
124 nullptr);
125 codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
126 &result_handler);
127 EXPECT_TRUE(decoded_successfully);
128 }

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::StandardMethodCodec::GetInstance(), and message.

## ◆ TEST() [90/291]

flutter::TEST | ( | StandardMethodCodec | ,
|  | HandlesMethodCallsWithArgument |
| ) |  |

Definition at line 53 of file standard_method_codec_unittests.cc.

53 {
54 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
55 MethodCall<> call("hello", std::make_unique<EncodableValue>(EncodableList{
56 EncodableValue(42),
57 EncodableValue("world"),
58 }));
59 auto encoded = codec.EncodeMethodCall(call);
60 ASSERT_NE(encoded.get(), nullptr);
61 std::unique_ptr<MethodCall<>> decoded = codec.DecodeMethodCall(*encoded);
62 ASSERT_NE(decoded.get(), nullptr);
63 EXPECT_TRUE(MethodCallsAreEqual(call, *decoded));
64 }

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::StandardMethodCodec::GetInstance().

## ◆ TEST() [91/291]

flutter::TEST | ( | StandardMethodCodec | ,
|  | HandlesMethodCallsWithNullArguments |
| ) |  |

Definition at line 43 of file standard_method_codec_unittests.cc.

43 {
44 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
45 MethodCall<> call("hello", nullptr);
46 auto encoded = codec.EncodeMethodCall(call);
47 ASSERT_NE(encoded.get(), nullptr);
48 std::unique_ptr<MethodCall<>> decoded = codec.DecodeMethodCall(*encoded);
49 ASSERT_NE(decoded.get(), nullptr);
50 EXPECT_TRUE(MethodCallsAreEqual(call, *decoded));
51 }

References flutter::MethodCodec< T >::DecodeMethodCall(), flutter::MethodCodec< T >::EncodeMethodCall(), and flutter::StandardMethodCodec::GetInstance().

## ◆ TEST() [92/291]

flutter::TEST | ( | StandardMethodCodec | ,
|  | HandlesSuccessEnvelopesWithNullResult |
| ) |  |

Definition at line 66 of file standard_method_codec_unittests.cc.

66 {
67 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
68 auto encoded = codec.EncodeSuccessEnvelope();
69 ASSERT_NE(encoded.get(), nullptr);
70 std::vector<uint8_t> bytes = {0x00, 0x00};
71 EXPECT_EQ(*encoded, bytes);
72
73 bool decoded_successfully = false;
74 MethodResultFunctions<> result_handler(
75 [&decoded_successfully](const EncodableValue* result) {
76 decoded_successfully = true;
77 EXPECT_EQ(result, nullptr);
78 },
79 nullptr, nullptr);
80 codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
81 &result_handler);
82 EXPECT_TRUE(decoded_successfully);
83 }

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::StandardMethodCodec::GetInstance().

## ◆ TEST() [93/291]

flutter::TEST | ( | StandardMethodCodec | ,
|  | HandlesSuccessEnvelopesWithResult |
| ) |  |

Definition at line 85 of file standard_method_codec_unittests.cc.

85 {
86 const StandardMethodCodec& codec = StandardMethodCodec::GetInstance();
87 EncodableValue result(42);
88 auto encoded = codec.EncodeSuccessEnvelope(&result);
89 ASSERT_NE(encoded.get(), nullptr);
90 std::vector<uint8_t> bytes = {0x00, 0x03, 0x2a, 0x00, 0x00, 0x00};
91 EXPECT_EQ(*encoded, bytes);
92
93 bool decoded_successfully = false;
94 MethodResultFunctions<> result_handler(
95 [&decoded_successfully](const EncodableValue* result) {
96 decoded_successfully = true;
97 EXPECT_EQ(std::get<int32_t>(*result), 42);
98 },
99 nullptr, nullptr);
100 codec.DecodeAndProcessResponseEnvelope(encoded->data(), encoded->size(),
101 &result_handler);
102 EXPECT_TRUE(decoded_successfully);
103 }

References flutter::MethodCodec< T >::DecodeAndProcessResponseEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), and flutter::StandardMethodCodec::GetInstance().

## ◆ TEST() [94/291]

flutter::TEST | ( | TextEditingDeltaTest | ,
|  | TestTextEditingDeltaConstructor |
| ) |  |

Definition at line 11 of file text_editing_delta_unittests.cc.

11 {
12 // Here we are simulating inserting an "o" at the end of "hell".
13 std::string old_text = "hell";
14 std::string replacement_text = "hello";
15 TextRange range(0, 4);
16
17 TextEditingDelta delta = TextEditingDelta(old_text, range, replacement_text);
18
19 EXPECT_EQ(delta.old_text(), old_text);
20 EXPECT_EQ(delta.delta_text(), "hello");
21 EXPECT_EQ(delta.delta_start(), 0);
22 EXPECT_EQ(delta.delta_end(), 4);
23 }

References flutter::TextEditingDelta::delta_end(), flutter::TextEditingDelta::delta_start(), flutter::TextEditingDelta::delta_text(), and flutter::TextEditingDelta::old_text().

## ◆ TEST() [95/291]

flutter::TEST | ( | TextEditingDeltaTest | ,
|  | TestTextEditingDeltaNonTextConstructor |
| ) |  |

Definition at line 25 of file text_editing_delta_unittests.cc.

25 {
26 // Here we are simulating inserting an "o" at the end of "hell".
27 std::string old_text = "hello";
28
29 TextEditingDelta delta = TextEditingDelta(old_text);
30
31 EXPECT_EQ(delta.old_text(), old_text);
32 EXPECT_EQ(delta.delta_text(), "");
33 EXPECT_EQ(delta.delta_start(), -1);
34 EXPECT_EQ(delta.delta_end(), -1);
35 }

References flutter::TextEditingDelta::delta_end(), flutter::TextEditingDelta::delta_start(), flutter::TextEditingDelta::delta_text(), and flutter::TextEditingDelta::old_text().

## ◆ TEST() [96/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddCodePoint |
| ) |  |

Definition at line 417 of file text_input_model_unittests.cc.

417 {
418 auto model = std::make_unique<TextInputModel>();
419 model->AddCodePoint('A');
420 model->AddCodePoint('B');
421 model->AddCodePoint(0x1f604);
422 model->AddCodePoint('D');
423 model->AddCodePoint('E');
424 EXPECT_EQ(model->selection(), TextRange(6));
425 EXPECT_EQ(model->composing_range(), TextRange(0));
426 EXPECT_STREQ(model->GetText().c_str(), "AB😄DE");
427 }

## ◆ TEST() [97/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddCodePointReverseSelection |
| ) |  |

Definition at line 439 of file text_input_model_unittests.cc.

439 {
440 auto model = std::make_unique<TextInputModel>();
441 model->SetText("ABCDE");
442 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
443 model->AddCodePoint('x');
444 EXPECT_EQ(model->selection(), TextRange(2));
445 EXPECT_EQ(model->composing_range(), TextRange(0));
446 EXPECT_STREQ(model->GetText().c_str(), "AxE");
447 }

## ◆ TEST() [98/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddCodePointReverseSelectionWideCharacter |
| ) |  |

Definition at line 459 of file text_input_model_unittests.cc.

459 {
460 auto model = std::make_unique<TextInputModel>();
461 model->SetText("ABCDE");
462 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
463 model->AddCodePoint(0x1f604);
464 EXPECT_EQ(model->selection(), TextRange(3));
465 EXPECT_EQ(model->composing_range(), TextRange(0));
466 EXPECT_STREQ(model->GetText().c_str(), "A😄E");
467 }

## ◆ TEST() [99/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddCodePointSelection |
| ) |  |

Definition at line 429 of file text_input_model_unittests.cc.

429 {
430 auto model = std::make_unique<TextInputModel>();
431 model->SetText("ABCDE");
432 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
433 model->AddCodePoint('x');
434 EXPECT_EQ(model->selection(), TextRange(2));
435 EXPECT_EQ(model->composing_range(), TextRange(0));
436 EXPECT_STREQ(model->GetText().c_str(), "AxE");
437 }

## ◆ TEST() [100/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddCodePointSelectionWideCharacter |
| ) |  |

Definition at line 449 of file text_input_model_unittests.cc.

449 {
450 auto model = std::make_unique<TextInputModel>();
451 model->SetText("ABCDE");
452 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
453 model->AddCodePoint(0x1f604);
454 EXPECT_EQ(model->selection(), TextRange(3));
455 EXPECT_EQ(model->composing_range(), TextRange(0));
456 EXPECT_STREQ(model->GetText().c_str(), "A😄E");
457 }

## ◆ TEST() [101/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddText |
| ) |  |

Definition at line 469 of file text_input_model_unittests.cc.

469 {
470 auto model = std::make_unique<TextInputModel>();
471 model->AddText(u"ABCDE");
472 model->AddText("😄");
473 model->AddText("FGHIJ");
474 EXPECT_EQ(model->selection(), TextRange(12));
475 EXPECT_EQ(model->composing_range(), TextRange(0));
476 EXPECT_STREQ(model->GetText().c_str(), "ABCDE😄FGHIJ");
477 }

## ◆ TEST() [102/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddTextReverseSelection |
| ) |  |

Definition at line 489 of file text_input_model_unittests.cc.

489 {
490 auto model = std::make_unique<TextInputModel>();
491 model->SetText("ABCDE");
492 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
493 model->AddText("xy");
494 EXPECT_EQ(model->selection(), TextRange(3));
495 EXPECT_EQ(model->composing_range(), TextRange(0));
496 EXPECT_STREQ(model->GetText().c_str(), "AxyE");
497 }

## ◆ TEST() [103/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddTextReverseSelectionWideCharacter |
| ) |  |

Definition at line 509 of file text_input_model_unittests.cc.

509 {
510 auto model = std::make_unique<TextInputModel>();
511 model->SetText("ABCDE");
512 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
513 model->AddText(u"😄🙃");
514 EXPECT_EQ(model->selection(), TextRange(5));
515 EXPECT_EQ(model->composing_range(), TextRange(0));
516 EXPECT_STREQ(model->GetText().c_str(), "A😄🙃E");
517 }

## ◆ TEST() [104/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddTextSelection |
| ) |  |

Definition at line 479 of file text_input_model_unittests.cc.

479 {
480 auto model = std::make_unique<TextInputModel>();
481 model->SetText("ABCDE");
482 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
483 model->AddText("xy");
484 EXPECT_EQ(model->selection(), TextRange(3));
485 EXPECT_EQ(model->composing_range(), TextRange(0));
486 EXPECT_STREQ(model->GetText().c_str(), "AxyE");
487 }

## ◆ TEST() [105/291]

flutter::TEST | ( | TextInputModel | ,
|  | AddTextSelectionWideCharacter |
| ) |  |

Definition at line 499 of file text_input_model_unittests.cc.

499 {
500 auto model = std::make_unique<TextInputModel>();
501 model->SetText("ABCDE");
502 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
503 model->AddText(u"😄🙃");
504 EXPECT_EQ(model->selection(), TextRange(5));
505 EXPECT_EQ(model->composing_range(), TextRange(0));
506 EXPECT_STREQ(model->GetText().c_str(), "A😄🙃E");
507 }

## ◆ TEST() [106/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceEnd |
| ) |  |

Definition at line 878 of file text_input_model_unittests.cc.

878 {
879 auto model = std::make_unique<TextInputModel>();
880 model->SetText("ABCDE");
881 EXPECT_TRUE(model->SetSelection(TextRange(5)));
882 ASSERT_TRUE(model->Backspace());
883 EXPECT_EQ(model->selection(), TextRange(4));
884 EXPECT_EQ(model->composing_range(), TextRange(0));
885 EXPECT_STREQ(model->GetText().c_str(), "ABCD");
886 }

## ◆ TEST() [107/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceEndComposing |
| ) |  |

Definition at line 962 of file text_input_model_unittests.cc.

962 {
963 auto model = std::make_unique<TextInputModel>();
964 model->SetText("ABCDE");
965 model->BeginComposing();
966 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
967 ASSERT_TRUE(model->Backspace());
968 EXPECT_EQ(model->selection(), TextRange(3));
969 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
970 EXPECT_STREQ(model->GetText().c_str(), "ABCE");
971 }

## ◆ TEST() [108/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceEndReverseComposing |
| ) |  |

Definition at line 973 of file text_input_model_unittests.cc.

973 {
974 auto model = std::make_unique<TextInputModel>();
975 model->SetText("ABCDE");
976 model->BeginComposing();
977 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
978 ASSERT_TRUE(model->Backspace());
979 EXPECT_EQ(model->selection(), TextRange(3));
980 EXPECT_EQ(model->composing_range(), TextRange(3, 1));
981 EXPECT_STREQ(model->GetText().c_str(), "ABCE");
982 }

## ◆ TEST() [109/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceMiddle |
| ) |  |

Definition at line 868 of file text_input_model_unittests.cc.

868 {
869 auto model = std::make_unique<TextInputModel>();
870 model->SetText("ABCDE");
871 EXPECT_TRUE(model->SetSelection(TextRange(2)));
872 ASSERT_TRUE(model->Backspace());
873 EXPECT_EQ(model->selection(), TextRange(1));
874 EXPECT_EQ(model->composing_range(), TextRange(0));
875 EXPECT_STREQ(model->GetText().c_str(), "ACDE");
876 }

## ◆ TEST() [110/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceMiddleComposing |
| ) |  |

Definition at line 940 of file text_input_model_unittests.cc.

940 {
941 auto model = std::make_unique<TextInputModel>();
942 model->SetText("ABCDE");
943 model->BeginComposing();
944 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
945 ASSERT_TRUE(model->Backspace());
946 EXPECT_EQ(model->selection(), TextRange(1));
947 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
948 EXPECT_STREQ(model->GetText().c_str(), "ACDE");
949 }

## ◆ TEST() [111/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceMiddleReverseComposing |
| ) |  |

Definition at line 951 of file text_input_model_unittests.cc.

951 {
952 auto model = std::make_unique<TextInputModel>();
953 model->SetText("ABCDE");
954 model->BeginComposing();
955 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
956 ASSERT_TRUE(model->Backspace());
957 EXPECT_EQ(model->selection(), TextRange(1));
958 EXPECT_EQ(model->composing_range(), TextRange(3, 1));
959 EXPECT_STREQ(model->GetText().c_str(), "ACDE");
960 }

## ◆ TEST() [112/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceReverseSelection |
| ) |  |

Definition at line 908 of file text_input_model_unittests.cc.

908 {
909 auto model = std::make_unique<TextInputModel>();
910 model->SetText("ABCDE");
911 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
912 ASSERT_TRUE(model->Delete());
913 EXPECT_EQ(model->selection(), TextRange(1));
914 EXPECT_EQ(model->composing_range(), TextRange(0));
915 EXPECT_STREQ(model->GetText().c_str(), "AE");
916 }

## ◆ TEST() [113/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceSelection |
| ) |  |

Definition at line 898 of file text_input_model_unittests.cc.

898 {
899 auto model = std::make_unique<TextInputModel>();
900 model->SetText("ABCDE");
901 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
902 ASSERT_TRUE(model->Delete());
903 EXPECT_EQ(model->selection(), TextRange(1));
904 EXPECT_EQ(model->composing_range(), TextRange(0));
905 EXPECT_STREQ(model->GetText().c_str(), "AE");
906 }

## ◆ TEST() [114/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceStart |
| ) |  |

Definition at line 858 of file text_input_model_unittests.cc.

858 {
859 auto model = std::make_unique<TextInputModel>();
860 model->SetText("ABCDE");
861 EXPECT_TRUE(model->SetSelection(TextRange(0)));
862 ASSERT_FALSE(model->Backspace());
863 EXPECT_EQ(model->selection(), TextRange(0));
864 EXPECT_EQ(model->composing_range(), TextRange(0));
865 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
866 }

## ◆ TEST() [115/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceStartComposing |
| ) |  |

Definition at line 918 of file text_input_model_unittests.cc.

918 {
919 auto model = std::make_unique<TextInputModel>();
920 model->SetText("ABCDE");
921 model->BeginComposing();
922 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
923 ASSERT_FALSE(model->Backspace());
924 EXPECT_EQ(model->selection(), TextRange(1));
925 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
926 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
927 }

## ◆ TEST() [116/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceStartReverseComposing |
| ) |  |

Definition at line 929 of file text_input_model_unittests.cc.

929 {
930 auto model = std::make_unique<TextInputModel>();
931 model->SetText("ABCDE");
932 model->BeginComposing();
933 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
934 ASSERT_FALSE(model->Backspace());
935 EXPECT_EQ(model->selection(), TextRange(1));
936 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
937 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
938 }

## ◆ TEST() [117/291]

flutter::TEST | ( | TextInputModel | ,
|  | BackspaceWideCharacters |
| ) |  |

Definition at line 888 of file text_input_model_unittests.cc.

888 {
889 auto model = std::make_unique<TextInputModel>();
890 model->SetText("😄🙃🤪🧐");
891 EXPECT_TRUE(model->SetSelection(TextRange(4)));
892 ASSERT_TRUE(model->Backspace());
893 EXPECT_EQ(model->selection(), TextRange(2));
894 EXPECT_EQ(model->composing_range(), TextRange(0));
895 EXPECT_STREQ(model->GetText().c_str(), "😄🤪🧐");
896 }

## ◆ TEST() [118/291]

flutter::TEST | ( | TextInputModel | ,
|  | CommitComposingNoTextWithNoSelection |
| ) |  |

Definition at line 230 of file text_input_model_unittests.cc.

230 {
231 auto model = std::make_unique<TextInputModel>();
232 model->SetText("ABCDE");
233 model->SetSelection(TextRange(0));
234
235 // Verify no changes on BeginComposing.
236 model->BeginComposing();
237 EXPECT_EQ(model->selection(), TextRange(0));
238 EXPECT_EQ(model->composing_range(), TextRange(0));
239 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
240
241 // Verify no changes on CommitComposing.
242 model->CommitComposing();
243 EXPECT_EQ(model->selection(), TextRange(0));
244 EXPECT_EQ(model->composing_range(), TextRange(0));
245 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
246
247 // Verify no changes on CommitComposing.
248 model->EndComposing();
249 EXPECT_EQ(model->selection(), TextRange(0));
250 EXPECT_EQ(model->composing_range(), TextRange(0));
251 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
252 }

## ◆ TEST() [119/291]

flutter::TEST | ( | TextInputModel | ,
|  | CommitComposingNoTextWithSelection |
| ) |  |

Definition at line 255 of file text_input_model_unittests.cc.

255 {
256 auto model = std::make_unique<TextInputModel>();
257 model->SetText("ABCDE");
258 model->SetSelection(TextRange(1, 3));
259
260 // Verify no changes on BeginComposing.
261 model->BeginComposing();
262 EXPECT_EQ(model->selection(), TextRange(1, 3));
263 EXPECT_EQ(model->composing_range(), TextRange(1));
264 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
265
266 // Verify no changes on CommitComposing.
267 model->CommitComposing();
268 EXPECT_EQ(model->selection(), TextRange(1, 3));
269 EXPECT_EQ(model->composing_range(), TextRange(1));
270 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
271
272 // Verify no changes on CommitComposing.
273 model->EndComposing();
274 EXPECT_EQ(model->selection(), TextRange(1, 3));
275 EXPECT_EQ(model->composing_range(), TextRange(0));
276 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
277 }

## ◆ TEST() [120/291]

flutter::TEST | ( | TextInputModel | ,
|  | CommitComposingTextWithNoSelection |
| ) |  |

Definition at line 280 of file text_input_model_unittests.cc.

280 {
281 auto model = std::make_unique<TextInputModel>();
282 model->SetText("ABCDE");
283 model->SetSelection(TextRange(1));
284
285 // Verify no changes on BeginComposing.
286 model->BeginComposing();
287 EXPECT_EQ(model->selection(), TextRange(1));
288 EXPECT_EQ(model->composing_range(), TextRange(1));
289 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
290
291 // Verify selection base, extent and composing extent increment as text is
292 // entered. Verify composing base does not change.
293 model->UpdateComposingText("つ");
294 EXPECT_EQ(model->selection(), TextRange(2));
295 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
296 EXPECT_STREQ(model->GetText().c_str(), "AつBCDE");
297 model->UpdateComposingText("つる");
298 EXPECT_EQ(model->selection(), TextRange(3));
299 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
300 EXPECT_STREQ(model->GetText().c_str(), "AつるBCDE");
301
302 // Verify that cursor position is set to correct offset from composing base.
303 model->UpdateComposingText("鶴");
304 EXPECT_TRUE(model->SetSelection(TextRange(1)));
305 EXPECT_EQ(model->selection(), TextRange(1));
306 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
307 EXPECT_STREQ(model->GetText().c_str(), "A鶴BCDE");
308
309 // Verify composing base is set to composing extent on commit.
310 model->CommitComposing();
311 EXPECT_EQ(model->selection(), TextRange(2));
312 EXPECT_EQ(model->composing_range(), TextRange(2));
313 EXPECT_STREQ(model->GetText().c_str(), "A鶴BCDE");
314
315 // Verify that further text entry increments the selection base, extent and
316 // the composing extent. Verify that composing base does not change.
317 model->UpdateComposingText("が");
318 EXPECT_EQ(model->selection(), TextRange(3));
319 EXPECT_EQ(model->composing_range(), TextRange(2, 3));
320 EXPECT_STREQ(model->GetText().c_str(), "A鶴がBCDE");
321
322 // Verify composing base is set to composing extent on commit.
323 model->CommitComposing();
324 EXPECT_EQ(model->selection(), TextRange(3));
325 EXPECT_EQ(model->composing_range(), TextRange(3));
326 EXPECT_STREQ(model->GetText().c_str(), "A鶴がBCDE");
327
328 // Verify no changes on EndComposing.
329 model->EndComposing();
330 EXPECT_EQ(model->selection(), TextRange(3));
331 EXPECT_EQ(model->composing_range(), TextRange(0));
332 EXPECT_STREQ(model->GetText().c_str(), "A鶴がBCDE");
333 }

## ◆ TEST() [121/291]

flutter::TEST | ( | TextInputModel | ,
|  | CommitComposingTextWithSelection |
| ) |  |

Definition at line 336 of file text_input_model_unittests.cc.

336 {
337 auto model = std::make_unique<TextInputModel>();
338 model->SetText("ABCDE");
339 model->SetSelection(TextRange(1, 3));
340
341 // Verify no changes on BeginComposing.
342 model->BeginComposing();
343 EXPECT_EQ(model->selection(), TextRange(1, 3));
344 EXPECT_EQ(model->composing_range(), TextRange(1));
345 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
346
347 // Verify selection is replaced and selection base, extent and composing
348 // extent increment to the position immediately after the composing text.
349 // Verify composing base does not change.
350 model->UpdateComposingText("つ");
351 EXPECT_EQ(model->selection(), TextRange(2));
352 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
353 EXPECT_STREQ(model->GetText().c_str(), "AつDE");
354
355 // Verify that further text entry increments the selection base, extent and
356 // the composing extent. Verify that composing base does not change.
357 model->UpdateComposingText("つる");
358 EXPECT_EQ(model->selection(), TextRange(3));
359 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
360 EXPECT_STREQ(model->GetText().c_str(), "AつるDE");
361
362 // Verify that cursor position is set to correct offset from composing base.
363 model->UpdateComposingText("鶴");
364 EXPECT_TRUE(model->SetSelection(TextRange(1)));
365 EXPECT_EQ(model->selection(), TextRange(1));
366 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
367 EXPECT_STREQ(model->GetText().c_str(), "A鶴DE");
368
369 // Verify composing base is set to composing extent on commit.
370 model->CommitComposing();
371 EXPECT_EQ(model->selection(), TextRange(2));
372 EXPECT_EQ(model->composing_range(), TextRange(2));
373 EXPECT_STREQ(model->GetText().c_str(), "A鶴DE");
374
375 // Verify that further text entry increments the selection base, extent and
376 // the composing extent. Verify that composing base does not change.
377 model->UpdateComposingText("が");
378 EXPECT_EQ(model->selection(), TextRange(3));
379 EXPECT_EQ(model->composing_range(), TextRange(2, 3));
380 EXPECT_STREQ(model->GetText().c_str(), "A鶴がDE");
381
382 // Verify composing base is set to composing extent on commit.
383 model->CommitComposing();
384 EXPECT_EQ(model->selection(), TextRange(3));
385 EXPECT_EQ(model->composing_range(), TextRange(3));
386 EXPECT_STREQ(model->GetText().c_str(), "A鶴がDE");
387
388 // Verify no changes on EndComposing.
389 model->EndComposing();
390 EXPECT_EQ(model->selection(), TextRange(3));
391 EXPECT_EQ(model->composing_range(), TextRange(0));
392 EXPECT_STREQ(model->GetText().c_str(), "A鶴がDE");
393 }

## ◆ TEST() [122/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteEnd |
| ) |  |

Definition at line 539 of file text_input_model_unittests.cc.

539 {
540 auto model = std::make_unique<TextInputModel>();
541 model->SetText("ABCDE");
542 EXPECT_TRUE(model->SetSelection(TextRange(5)));
543 ASSERT_FALSE(model->Delete());
544 EXPECT_EQ(model->selection(), TextRange(5));
545 EXPECT_EQ(model->composing_range(), TextRange(0));
546 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
547 }

## ◆ TEST() [123/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteEndComposing |
| ) |  |

Definition at line 627 of file text_input_model_unittests.cc.

627 {
628 auto model = std::make_unique<TextInputModel>();
629 model->SetText("ABCDE");
630 model->BeginComposing();
631 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
632 ASSERT_FALSE(model->Delete());
633 EXPECT_EQ(model->selection(), TextRange(4));
634 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
635 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
636 }

## ◆ TEST() [124/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteEndReverseComposing |
| ) |  |

Definition at line 638 of file text_input_model_unittests.cc.

638 {
639 auto model = std::make_unique<TextInputModel>();
640 model->SetText("ABCDE");
641 model->BeginComposing();
642 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
643 ASSERT_FALSE(model->Delete());
644 EXPECT_EQ(model->selection(), TextRange(4));
645 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
646 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
647 }

## ◆ TEST() [125/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteMiddle |
| ) |  |

Definition at line 529 of file text_input_model_unittests.cc.

529 {
530 auto model = std::make_unique<TextInputModel>();
531 model->SetText("ABCDE");
532 EXPECT_TRUE(model->SetSelection(TextRange(2)));
533 ASSERT_TRUE(model->Delete());
534 EXPECT_EQ(model->selection(), TextRange(2));
535 EXPECT_EQ(model->composing_range(), TextRange(0));
536 EXPECT_STREQ(model->GetText().c_str(), "ABDE");
537 }

## ◆ TEST() [126/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteMiddleComposing |
| ) |  |

Definition at line 605 of file text_input_model_unittests.cc.

605 {
606 auto model = std::make_unique<TextInputModel>();
607 model->SetText("ABCDE");
608 model->BeginComposing();
609 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
610 ASSERT_TRUE(model->Delete());
611 EXPECT_EQ(model->selection(), TextRange(2));
612 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
613 EXPECT_STREQ(model->GetText().c_str(), "ABDE");
614 }

## ◆ TEST() [127/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteMiddleReverseComposing |
| ) |  |

Definition at line 616 of file text_input_model_unittests.cc.

616 {
617 auto model = std::make_unique<TextInputModel>();
618 model->SetText("ABCDE");
619 model->BeginComposing();
620 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
621 ASSERT_TRUE(model->Delete());
622 EXPECT_EQ(model->selection(), TextRange(2));
623 EXPECT_EQ(model->composing_range(), TextRange(3, 1));
624 EXPECT_STREQ(model->GetText().c_str(), "ABDE");
625 }

## ◆ TEST() [128/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteReverseSelection |
| ) |  |

Definition at line 569 of file text_input_model_unittests.cc.

569 {
570 auto model = std::make_unique<TextInputModel>();
571 model->SetText("ABCDE");
572 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
573 ASSERT_TRUE(model->Delete());
574 EXPECT_EQ(model->selection(), TextRange(1));
575 EXPECT_EQ(model->composing_range(), TextRange(0));
576 EXPECT_STREQ(model->GetText().c_str(), "AE");
577 }

## ◆ TEST() [129/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSelection |
| ) |  |

Definition at line 559 of file text_input_model_unittests.cc.

559 {
560 auto model = std::make_unique<TextInputModel>();
561 model->SetText("ABCDE");
562 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
563 ASSERT_TRUE(model->Delete());
564 EXPECT_EQ(model->selection(), TextRange(1));
565 EXPECT_EQ(model->composing_range(), TextRange(0));
566 EXPECT_STREQ(model->GetText().c_str(), "AE");
567 }

## ◆ TEST() [130/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteStart |
| ) |  |

Definition at line 519 of file text_input_model_unittests.cc.

519 {
520 auto model = std::make_unique<TextInputModel>();
521 model->SetText("ABCDE");
522 EXPECT_TRUE(model->SetSelection(TextRange(0)));
523 ASSERT_TRUE(model->Delete());
524 EXPECT_EQ(model->selection(), TextRange(0));
525 EXPECT_EQ(model->composing_range(), TextRange(0));
526 EXPECT_STREQ(model->GetText().c_str(), "BCDE");
527 }

## ◆ TEST() [131/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteStartComposing |
| ) |  |

Definition at line 579 of file text_input_model_unittests.cc.

579 {
580 auto model = std::make_unique<TextInputModel>();
581 model->SetText("ABCDE");
582 model->BeginComposing();
583 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
584 EXPECT_EQ(model->selection(), TextRange(1));
585 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
586 ASSERT_TRUE(model->Delete());
587 EXPECT_EQ(model->selection(), TextRange(1));
588 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
589 EXPECT_STREQ(model->GetText().c_str(), "ACDE");
590 }

## ◆ TEST() [132/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteStartReverseComposing |
| ) |  |

Definition at line 592 of file text_input_model_unittests.cc.

592 {
593 auto model = std::make_unique<TextInputModel>();
594 model->SetText("ABCDE");
595 model->BeginComposing();
596 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
597 EXPECT_EQ(model->selection(), TextRange(1));
598 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
599 ASSERT_TRUE(model->Delete());
600 EXPECT_EQ(model->selection(), TextRange(1));
601 EXPECT_EQ(model->composing_range(), TextRange(3, 1));
602 EXPECT_STREQ(model->GetText().c_str(), "ACDE");
603 }

## ◆ TEST() [133/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAfterCursor |
| ) |  |

Definition at line 775 of file text_input_model_unittests.cc.

775 {
776 auto model = std::make_unique<TextInputModel>();
777 model->SetText("ABCDE");
778 EXPECT_TRUE(model->SetSelection(TextRange(2)));
779 EXPECT_TRUE(model->DeleteSurrounding(1, 1));
780 EXPECT_EQ(model->selection(), TextRange(2));
781 EXPECT_EQ(model->composing_range(), TextRange(0));
782 EXPECT_STREQ(model->GetText().c_str(), "ABCE");
783 }

## ◆ TEST() [134/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAfterCursorAll |
| ) |  |

Definition at line 796 of file text_input_model_unittests.cc.

796 {
797 auto model = std::make_unique<TextInputModel>();
798 model->SetText("ABCDE");
799 EXPECT_TRUE(model->SetSelection(TextRange(2)));
800 EXPECT_TRUE(model->DeleteSurrounding(1, 2));
801 EXPECT_EQ(model->selection(), TextRange(2));
802 EXPECT_EQ(model->composing_range(), TextRange(0));
803 EXPECT_STREQ(model->GetText().c_str(), "ABC");
804 }

## ◆ TEST() [135/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAfterCursorAllComposing |
| ) |  |

Definition at line 806 of file text_input_model_unittests.cc.

806 {
807 auto model = std::make_unique<TextInputModel>();
808 model->SetText("ABCDE");
809 model->BeginComposing();
810 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
811 EXPECT_TRUE(model->DeleteSurrounding(1, 2));
812 EXPECT_EQ(model->selection(), TextRange(1));
813 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
814 EXPECT_STREQ(model->GetText().c_str(), "ABE");
815 }

## ◆ TEST() [136/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAfterCursorComposing |
| ) |  |

Definition at line 785 of file text_input_model_unittests.cc.

785 {
786 auto model = std::make_unique<TextInputModel>();
787 model->SetText("ABCDE");
788 model->BeginComposing();
789 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
790 EXPECT_TRUE(model->DeleteSurrounding(1, 1));
791 EXPECT_EQ(model->selection(), TextRange(1));
792 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
793 EXPECT_STREQ(model->GetText().c_str(), "ABDE");
794 }

## ◆ TEST() [137/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAfterCursorGreedy |
| ) |  |

Definition at line 817 of file text_input_model_unittests.cc.

817 {
818 auto model = std::make_unique<TextInputModel>();
819 model->SetText("ABCDE");
820 EXPECT_TRUE(model->SetSelection(TextRange(2)));
821 EXPECT_TRUE(model->DeleteSurrounding(1, 3));
822 EXPECT_EQ(model->selection(), TextRange(2));
823 EXPECT_EQ(model->composing_range(), TextRange(0));
824 EXPECT_STREQ(model->GetText().c_str(), "ABC");
825 }

## ◆ TEST() [138/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAfterCursorGreedyComposing |
| ) |  |

Definition at line 827 of file text_input_model_unittests.cc.

827 {
828 auto model = std::make_unique<TextInputModel>();
829 model->SetText("ABCDE");
830 model->BeginComposing();
831 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
832 EXPECT_TRUE(model->DeleteSurrounding(1, 3));
833 EXPECT_EQ(model->selection(), TextRange(1));
834 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
835 EXPECT_STREQ(model->GetText().c_str(), "ABE");
836 }

## ◆ TEST() [139/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAtCursor |
| ) |  |

Definition at line 649 of file text_input_model_unittests.cc.

649 {
650 auto model = std::make_unique<TextInputModel>();
651 model->SetText("ABCDE");
652 EXPECT_TRUE(model->SetSelection(TextRange(2)));
653 EXPECT_TRUE(model->DeleteSurrounding(0, 1));
654 EXPECT_EQ(model->selection(), TextRange(2));
655 EXPECT_EQ(model->composing_range(), TextRange(0));
656 EXPECT_STREQ(model->GetText().c_str(), "ABDE");
657 }

## ◆ TEST() [140/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAtCursorAll |
| ) |  |

Definition at line 670 of file text_input_model_unittests.cc.

670 {
671 auto model = std::make_unique<TextInputModel>();
672 model->SetText("ABCDE");
673 EXPECT_TRUE(model->SetSelection(TextRange(2)));
674 EXPECT_TRUE(model->DeleteSurrounding(0, 3));
675 EXPECT_EQ(model->selection(), TextRange(2));
676 EXPECT_EQ(model->composing_range(), TextRange(0));
677 EXPECT_STREQ(model->GetText().c_str(), "AB");
678 }

## ◆ TEST() [141/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAtCursorAllComposing |
| ) |  |

Definition at line 680 of file text_input_model_unittests.cc.

680 {
681 auto model = std::make_unique<TextInputModel>();
682 model->SetText("ABCDE");
683 model->BeginComposing();
684 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
685 EXPECT_TRUE(model->DeleteSurrounding(0, 2));
686 EXPECT_EQ(model->selection(), TextRange(2));
687 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
688 EXPECT_STREQ(model->GetText().c_str(), "ABE");
689 }

## ◆ TEST() [142/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAtCursorComposing |
| ) |  |

Definition at line 659 of file text_input_model_unittests.cc.

659 {
660 auto model = std::make_unique<TextInputModel>();
661 model->SetText("ABCDE");
662 model->BeginComposing();
663 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
664 EXPECT_TRUE(model->DeleteSurrounding(0, 1));
665 EXPECT_EQ(model->selection(), TextRange(2));
666 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
667 EXPECT_STREQ(model->GetText().c_str(), "ABDE");
668 }

## ◆ TEST() [143/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAtCursorGreedy |
| ) |  |

Definition at line 691 of file text_input_model_unittests.cc.

691 {
692 auto model = std::make_unique<TextInputModel>();
693 model->SetText("ABCDE");
694 EXPECT_TRUE(model->SetSelection(TextRange(2)));
695 EXPECT_TRUE(model->DeleteSurrounding(0, 4));
696 EXPECT_EQ(model->selection(), TextRange(2));
697 EXPECT_EQ(model->composing_range(), TextRange(0));
698 EXPECT_STREQ(model->GetText().c_str(), "AB");
699 }

## ◆ TEST() [144/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingAtCursorGreedyComposing |
| ) |  |

Definition at line 701 of file text_input_model_unittests.cc.

701 {
702 auto model = std::make_unique<TextInputModel>();
703 model->SetText("ABCDE");
704 model->BeginComposing();
705 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
706 EXPECT_TRUE(model->DeleteSurrounding(0, 4));
707 EXPECT_EQ(model->selection(), TextRange(2));
708 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
709 EXPECT_STREQ(model->GetText().c_str(), "ABE");
710 }

## ◆ TEST() [145/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingBeforeCursor |
| ) |  |

Definition at line 712 of file text_input_model_unittests.cc.

712 {
713 auto model = std::make_unique<TextInputModel>();
714 model->SetText("ABCDE");
715 EXPECT_TRUE(model->SetSelection(TextRange(2)));
716 EXPECT_TRUE(model->DeleteSurrounding(-1, 1));
717 EXPECT_EQ(model->selection(), TextRange(1));
718 EXPECT_EQ(model->composing_range(), TextRange(0));
719 EXPECT_STREQ(model->GetText().c_str(), "ACDE");
720 }

## ◆ TEST() [146/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingBeforeCursorAll |
| ) |  |

Definition at line 733 of file text_input_model_unittests.cc.

733 {
734 auto model = std::make_unique<TextInputModel>();
735 model->SetText("ABCDE");
736 EXPECT_TRUE(model->SetSelection(TextRange(2)));
737 EXPECT_TRUE(model->DeleteSurrounding(-2, 2));
738 EXPECT_EQ(model->selection(), TextRange(0));
739 EXPECT_EQ(model->composing_range(), TextRange(0));
740 EXPECT_STREQ(model->GetText().c_str(), "CDE");
741 }

## ◆ TEST() [147/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingBeforeCursorAllComposing |
| ) |  |

Definition at line 743 of file text_input_model_unittests.cc.

743 {
744 auto model = std::make_unique<TextInputModel>();
745 model->SetText("ABCDE");
746 model->BeginComposing();
747 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 2));
748 EXPECT_TRUE(model->DeleteSurrounding(-2, 2));
749 EXPECT_EQ(model->selection(), TextRange(1));
750 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
751 EXPECT_STREQ(model->GetText().c_str(), "ADE");
752 }

## ◆ TEST() [148/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingBeforeCursorComposing |
| ) |  |

Definition at line 722 of file text_input_model_unittests.cc.

722 {
723 auto model = std::make_unique<TextInputModel>();
724 model->SetText("ABCDE");
725 model->BeginComposing();
726 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 2));
727 EXPECT_TRUE(model->DeleteSurrounding(-1, 1));
728 EXPECT_EQ(model->selection(), TextRange(2));
729 EXPECT_EQ(model->composing_range(), TextRange(1, 3));
730 EXPECT_STREQ(model->GetText().c_str(), "ABDE");
731 }

## ◆ TEST() [149/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingBeforeCursorGreedy |
| ) |  |

Definition at line 754 of file text_input_model_unittests.cc.

754 {
755 auto model = std::make_unique<TextInputModel>();
756 model->SetText("ABCDE");
757 EXPECT_TRUE(model->SetSelection(TextRange(2)));
758 EXPECT_TRUE(model->DeleteSurrounding(-3, 3));
759 EXPECT_EQ(model->selection(), TextRange(0));
760 EXPECT_EQ(model->composing_range(), TextRange(0));
761 EXPECT_STREQ(model->GetText().c_str(), "CDE");
762 }

## ◆ TEST() [150/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingBeforeCursorGreedyComposing |
| ) |  |

Definition at line 764 of file text_input_model_unittests.cc.

764 {
765 auto model = std::make_unique<TextInputModel>();
766 model->SetText("ABCDE");
767 model->BeginComposing();
768 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 2));
769 EXPECT_TRUE(model->DeleteSurrounding(-3, 3));
770 EXPECT_EQ(model->selection(), TextRange(1));
771 EXPECT_EQ(model->composing_range(), TextRange(1, 2));
772 EXPECT_STREQ(model->GetText().c_str(), "ADE");
773 }

## ◆ TEST() [151/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingReverseSelection |
| ) |  |

Definition at line 848 of file text_input_model_unittests.cc.

848 {
849 auto model = std::make_unique<TextInputModel>();
850 model->SetText("ABCDE");
851 EXPECT_TRUE(model->SetSelection(TextRange(4, 3)));
852 EXPECT_TRUE(model->DeleteSurrounding(0, 1));
853 EXPECT_EQ(model->selection(), TextRange(3));
854 EXPECT_EQ(model->composing_range(), TextRange(0));
855 EXPECT_STREQ(model->GetText().c_str(), "ABCE");
856 }

## ◆ TEST() [152/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteSurroundingSelection |
| ) |  |

Definition at line 838 of file text_input_model_unittests.cc.

838 {
839 auto model = std::make_unique<TextInputModel>();
840 model->SetText("ABCDE");
841 EXPECT_TRUE(model->SetSelection(TextRange(2, 3)));
842 EXPECT_TRUE(model->DeleteSurrounding(0, 1));
843 EXPECT_EQ(model->selection(), TextRange(3));
844 EXPECT_EQ(model->composing_range(), TextRange(0));
845 EXPECT_STREQ(model->GetText().c_str(), "ABCE");
846 }

## ◆ TEST() [153/291]

flutter::TEST | ( | TextInputModel | ,
|  | DeleteWideCharacters |
| ) |  |

Definition at line 549 of file text_input_model_unittests.cc.

549 {
550 auto model = std::make_unique<TextInputModel>();
551 model->SetText("😄🙃🤪🧐");
552 EXPECT_TRUE(model->SetSelection(TextRange(4)));
553 ASSERT_TRUE(model->Delete());
554 EXPECT_EQ(model->selection(), TextRange(4));
555 EXPECT_EQ(model->composing_range(), TextRange(0));
556 EXPECT_STREQ(model->GetText().c_str(), "😄🙃🧐");
557 }

## ◆ TEST() [154/291]

flutter::TEST | ( | TextInputModel | ,
|  | GetCursorOffset |
| ) |  |

Definition at line 1702 of file text_input_model_unittests.cc.

1702 {
1703 auto model = std::make_unique<TextInputModel>();
1704 // These characters take 1, 2, 3 and 4 bytes in UTF-8.
1705 model->SetText("$¢€𐍈");
1706 EXPECT_TRUE(model->SetSelection(TextRange(0)));
1707 EXPECT_EQ(model->GetCursorOffset(), 0);
1708 EXPECT_TRUE(model->MoveCursorForward());
1709 EXPECT_EQ(model->GetCursorOffset(), 1);
1710 EXPECT_TRUE(model->MoveCursorForward());
1711 EXPECT_EQ(model->GetCursorOffset(), 3);
1712 EXPECT_TRUE(model->MoveCursorForward());
1713 EXPECT_EQ(model->GetCursorOffset(), 6);
1714 EXPECT_TRUE(model->MoveCursorForward());
1715 EXPECT_EQ(model->GetCursorOffset(), 10);
1716 }

## ◆ TEST() [155/291]

flutter::TEST | ( | TextInputModel | ,
|  | GetCursorOffsetReverseSelection |
| ) |  |

Definition at line 1725 of file text_input_model_unittests.cc.

1725 {
1726 auto model = std::make_unique<TextInputModel>();
1727 model->SetText("ABCDE");
1728 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
1729 EXPECT_EQ(model->GetCursorOffset(), 1);
1730 }

## ◆ TEST() [156/291]

flutter::TEST | ( | TextInputModel | ,
|  | GetCursorOffsetSelection |
| ) |  |

Definition at line 1718 of file text_input_model_unittests.cc.

1718 {
1719 auto model = std::make_unique<TextInputModel>();
1720 model->SetText("ABCDE");
1721 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
1722 EXPECT_EQ(model->GetCursorOffset(), 4);
1723 }

## ◆ TEST() [157/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackEnd |
| ) |  |

Definition at line 1130 of file text_input_model_unittests.cc.

1130 {
1131 auto model = std::make_unique<TextInputModel>();
1132 model->SetText("ABCDE");
1133 EXPECT_TRUE(model->SetSelection(TextRange(5)));
1134 EXPECT_TRUE(model->MoveCursorBack());
1135 EXPECT_EQ(model->selection(), TextRange(4));
1136 EXPECT_EQ(model->composing_range(), TextRange(0));
1137 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1138 }

## ◆ TEST() [158/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackEndComposing |
| ) |  |

Definition at line 1216 of file text_input_model_unittests.cc.

1216 {
1217 auto model = std::make_unique<TextInputModel>();
1218 model->SetText("ABCDE");
1219 model->BeginComposing();
1220 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
1221 EXPECT_TRUE(model->MoveCursorBack());
1222 EXPECT_EQ(model->selection(), TextRange(3));
1223 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1224 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1225 }

## ◆ TEST() [159/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackEndReverseComposing |
| ) |  |

Definition at line 1227 of file text_input_model_unittests.cc.

1227 {
1228 auto model = std::make_unique<TextInputModel>();
1229 model->SetText("ABCDE");
1230 model->BeginComposing();
1231 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
1232 EXPECT_TRUE(model->MoveCursorBack());
1233 EXPECT_EQ(model->selection(), TextRange(3));
1234 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1235 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1236 }

## ◆ TEST() [160/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackMiddle |
| ) |  |

Definition at line 1120 of file text_input_model_unittests.cc.

1120 {
1121 auto model = std::make_unique<TextInputModel>();
1122 model->SetText("ABCDE");
1123 EXPECT_TRUE(model->SetSelection(TextRange(2)));
1124 EXPECT_TRUE(model->MoveCursorBack());
1125 EXPECT_EQ(model->selection(), TextRange(1));
1126 EXPECT_EQ(model->composing_range(), TextRange(0));
1127 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1128 }

## ◆ TEST() [161/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackMiddleComposing |
| ) |  |

Definition at line 1194 of file text_input_model_unittests.cc.

1194 {
1195 auto model = std::make_unique<TextInputModel>();
1196 model->SetText("ABCDE");
1197 model->BeginComposing();
1198 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
1199 EXPECT_TRUE(model->MoveCursorBack());
1200 EXPECT_EQ(model->selection(), TextRange(1));
1201 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1202 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1203 }

## ◆ TEST() [162/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackMiddleReverseComposing |
| ) |  |

Definition at line 1205 of file text_input_model_unittests.cc.

1205 {
1206 auto model = std::make_unique<TextInputModel>();
1207 model->SetText("ABCDE");
1208 model->BeginComposing();
1209 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
1210 EXPECT_TRUE(model->MoveCursorBack());
1211 EXPECT_EQ(model->selection(), TextRange(1));
1212 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1213 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1214 }

## ◆ TEST() [163/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackReverseSelection |
| ) |  |

Definition at line 1160 of file text_input_model_unittests.cc.

1160 {
1161 auto model = std::make_unique<TextInputModel>();
1162 model->SetText("ABCDE");
1163 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
1164 EXPECT_TRUE(model->MoveCursorBack());
1165 EXPECT_EQ(model->selection(), TextRange(1));
1166 EXPECT_EQ(model->composing_range(), TextRange(0));
1167 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1168 }

## ◆ TEST() [164/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackSelection |
| ) |  |

Definition at line 1150 of file text_input_model_unittests.cc.

1150 {
1151 auto model = std::make_unique<TextInputModel>();
1152 model->SetText("ABCDE");
1153 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
1154 EXPECT_TRUE(model->MoveCursorBack());
1155 EXPECT_EQ(model->selection(), TextRange(1));
1156 EXPECT_EQ(model->composing_range(), TextRange(0));
1157 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1158 }

## ◆ TEST() [165/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackStart |
| ) |  |

Definition at line 1110 of file text_input_model_unittests.cc.

1110 {
1111 auto model = std::make_unique<TextInputModel>();
1112 model->SetText("ABCDE");
1113 EXPECT_TRUE(model->SetSelection(TextRange(0)));
1114 EXPECT_FALSE(model->MoveCursorBack());
1115 EXPECT_EQ(model->selection(), TextRange(0));
1116 EXPECT_EQ(model->composing_range(), TextRange(0));
1117 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1118 }

## ◆ TEST() [166/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackStartComposing |
| ) |  |

Definition at line 1170 of file text_input_model_unittests.cc.

1170 {
1171 auto model = std::make_unique<TextInputModel>();
1172 model->SetText("ABCDE");
1173 model->BeginComposing();
1174 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
1175 EXPECT_TRUE(model->SetSelection(TextRange(1)));
1176 EXPECT_FALSE(model->MoveCursorBack());
1177 EXPECT_EQ(model->selection(), TextRange(1));
1178 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1179 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1180 }

## ◆ TEST() [167/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackStartReverseComposing |
| ) |  |

Definition at line 1182 of file text_input_model_unittests.cc.

1182 {
1183 auto model = std::make_unique<TextInputModel>();
1184 model->SetText("ABCDE");
1185 model->BeginComposing();
1186 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
1187 EXPECT_TRUE(model->SetSelection(TextRange(1)));
1188 EXPECT_FALSE(model->MoveCursorBack());
1189 EXPECT_EQ(model->selection(), TextRange(1));
1190 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1191 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1192 }

## ◆ TEST() [168/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorBackWideCharacters |
| ) |  |

Definition at line 1140 of file text_input_model_unittests.cc.

1140 {
1141 auto model = std::make_unique<TextInputModel>();
1142 model->SetText("😄🙃🤪🧐");
1143 EXPECT_TRUE(model->SetSelection(TextRange(4)));
1144 ASSERT_TRUE(model->MoveCursorBack());
1145 EXPECT_EQ(model->selection(), TextRange(2));
1146 EXPECT_EQ(model->composing_range(), TextRange(0));
1147 EXPECT_STREQ(model->GetText().c_str(), "😄🙃🤪🧐");
1148 }

## ◆ TEST() [169/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardEnd |
| ) |  |

Definition at line 1004 of file text_input_model_unittests.cc.

1004 {
1005 auto model = std::make_unique<TextInputModel>();
1006 model->SetText("ABCDE");
1007 EXPECT_TRUE(model->SetSelection(TextRange(5)));
1008 EXPECT_FALSE(model->MoveCursorForward());
1009 EXPECT_EQ(model->selection(), TextRange(5));
1010 EXPECT_EQ(model->composing_range(), TextRange(0));
1011 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1012 }

## ◆ TEST() [170/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardEndComposing |
| ) |  |

Definition at line 1088 of file text_input_model_unittests.cc.

1088 {
1089 auto model = std::make_unique<TextInputModel>();
1090 model->SetText("ABCDE");
1091 model->BeginComposing();
1092 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
1093 EXPECT_FALSE(model->MoveCursorForward());
1094 EXPECT_EQ(model->selection(), TextRange(4));
1095 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1096 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1097 }

## ◆ TEST() [171/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardEndReverseComposing |
| ) |  |

Definition at line 1099 of file text_input_model_unittests.cc.

1099 {
1100 auto model = std::make_unique<TextInputModel>();
1101 model->SetText("ABCDE");
1102 model->BeginComposing();
1103 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
1104 EXPECT_FALSE(model->MoveCursorForward());
1105 EXPECT_EQ(model->selection(), TextRange(4));
1106 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1107 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1108 }

## ◆ TEST() [172/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardMiddle |
| ) |  |

Definition at line 994 of file text_input_model_unittests.cc.

994 {
995 auto model = std::make_unique<TextInputModel>();
996 model->SetText("ABCDE");
997 EXPECT_TRUE(model->SetSelection(TextRange(2)));
998 EXPECT_TRUE(model->MoveCursorForward());
999 EXPECT_EQ(model->selection(), TextRange(3));
1000 EXPECT_EQ(model->composing_range(), TextRange(0));
1001 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1002 }

## ◆ TEST() [173/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardMiddleComposing |
| ) |  |

Definition at line 1066 of file text_input_model_unittests.cc.

1066 {
1067 auto model = std::make_unique<TextInputModel>();
1068 model->SetText("ABCDE");
1069 model->BeginComposing();
1070 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
1071 EXPECT_TRUE(model->MoveCursorForward());
1072 EXPECT_EQ(model->selection(), TextRange(3));
1073 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1074 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1075 }

## ◆ TEST() [174/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardMiddleReverseComposing |
| ) |  |

Definition at line 1077 of file text_input_model_unittests.cc.

1077 {
1078 auto model = std::make_unique<TextInputModel>();
1079 model->SetText("ABCDE");
1080 model->BeginComposing();
1081 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
1082 EXPECT_TRUE(model->MoveCursorForward());
1083 EXPECT_EQ(model->selection(), TextRange(3));
1084 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1085 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1086 }

## ◆ TEST() [175/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardReverseSelection |
| ) |  |

Definition at line 1034 of file text_input_model_unittests.cc.

1034 {
1035 auto model = std::make_unique<TextInputModel>();
1036 model->SetText("ABCDE");
1037 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
1038 EXPECT_TRUE(model->MoveCursorForward());
1039 EXPECT_EQ(model->selection(), TextRange(4));
1040 EXPECT_EQ(model->composing_range(), TextRange(0));
1041 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1042 }

## ◆ TEST() [176/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardSelection |
| ) |  |

Definition at line 1024 of file text_input_model_unittests.cc.

1024 {
1025 auto model = std::make_unique<TextInputModel>();
1026 model->SetText("ABCDE");
1027 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
1028 EXPECT_TRUE(model->MoveCursorForward());
1029 EXPECT_EQ(model->selection(), TextRange(4));
1030 EXPECT_EQ(model->composing_range(), TextRange(0));
1031 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1032 }

## ◆ TEST() [177/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardStart |
| ) |  |

Definition at line 984 of file text_input_model_unittests.cc.

984 {
985 auto model = std::make_unique<TextInputModel>();
986 model->SetText("ABCDE");
987 EXPECT_TRUE(model->SetSelection(TextRange(0)));
988 EXPECT_TRUE(model->MoveCursorForward());
989 EXPECT_EQ(model->selection(), TextRange(1));
990 EXPECT_EQ(model->composing_range(), TextRange(0));
991 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
992 }

## ◆ TEST() [178/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardStartComposing |
| ) |  |

Definition at line 1044 of file text_input_model_unittests.cc.

1044 {
1045 auto model = std::make_unique<TextInputModel>();
1046 model->SetText("ABCDE");
1047 model->BeginComposing();
1048 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
1049 EXPECT_TRUE(model->MoveCursorForward());
1050 EXPECT_EQ(model->selection(), TextRange(2));
1051 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1052 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1053 }

## ◆ TEST() [179/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardStartReverseComposing |
| ) |  |

Definition at line 1055 of file text_input_model_unittests.cc.

1055 {
1056 auto model = std::make_unique<TextInputModel>();
1057 model->SetText("ABCDE");
1058 model->BeginComposing();
1059 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
1060 EXPECT_TRUE(model->MoveCursorForward());
1061 EXPECT_EQ(model->selection(), TextRange(2));
1062 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1063 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1064 }

## ◆ TEST() [180/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorForwardWideCharacters |
| ) |  |

Definition at line 1014 of file text_input_model_unittests.cc.

1014 {
1015 auto model = std::make_unique<TextInputModel>();
1016 model->SetText("😄🙃🤪🧐");
1017 EXPECT_TRUE(model->SetSelection(TextRange(4)));
1018 ASSERT_TRUE(model->MoveCursorForward());
1019 EXPECT_EQ(model->selection(), TextRange(6));
1020 EXPECT_EQ(model->composing_range(), TextRange(0));
1021 EXPECT_STREQ(model->GetText().c_str(), "😄🙃🤪🧐");
1022 }

## ◆ TEST() [181/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningEnd |
| ) |  |

Definition at line 1278 of file text_input_model_unittests.cc.

1278 {
1279 auto model = std::make_unique<TextInputModel>();
1280 model->SetText("ABCDE");
1281 EXPECT_TRUE(model->SetSelection(TextRange(5)));
1282 EXPECT_TRUE(model->MoveCursorToBeginning());
1283 EXPECT_EQ(model->selection(), TextRange(0));
1284 EXPECT_EQ(model->composing_range(), TextRange(0));
1285 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1286 }

## ◆ TEST() [182/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningEndComposing |
| ) |  |

Definition at line 1426 of file text_input_model_unittests.cc.

1426 {
1427 auto model = std::make_unique<TextInputModel>();
1428 model->SetText("ABCDE");
1429 model->BeginComposing();
1430 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
1431 EXPECT_TRUE(model->MoveCursorToBeginning());
1432 EXPECT_EQ(model->selection(), TextRange(1));
1433 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1434 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1435 }

## ◆ TEST() [183/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningEndReverseComposing |
| ) |  |

Definition at line 1448 of file text_input_model_unittests.cc.

1448 {
1449 auto model = std::make_unique<TextInputModel>();
1450 model->SetText("ABCDE");
1451 model->BeginComposing();
1452 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
1453 EXPECT_TRUE(model->MoveCursorToBeginning());
1454 EXPECT_EQ(model->selection(), TextRange(1));
1455 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1456 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1457 }

## ◆ TEST() [184/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningMiddle |
| ) |  |

Definition at line 1258 of file text_input_model_unittests.cc.

1258 {
1259 auto model = std::make_unique<TextInputModel>();
1260 model->SetText("ABCDE");
1261 EXPECT_TRUE(model->SetSelection(TextRange(2)));
1262 EXPECT_TRUE(model->MoveCursorToBeginning());
1263 EXPECT_EQ(model->selection(), TextRange(0));
1264 EXPECT_EQ(model->composing_range(), TextRange(0));
1265 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1266 }

## ◆ TEST() [185/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningMiddleComposing |
| ) |  |

Definition at line 1382 of file text_input_model_unittests.cc.

1382 {
1383 auto model = std::make_unique<TextInputModel>();
1384 model->SetText("ABCDE");
1385 model->BeginComposing();
1386 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
1387 EXPECT_TRUE(model->MoveCursorToBeginning());
1388 EXPECT_EQ(model->selection(), TextRange(1));
1389 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1390 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1391 }

## ◆ TEST() [186/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningMiddleReverseComposing |
| ) |  |

Definition at line 1404 of file text_input_model_unittests.cc.

1404 {
1405 auto model = std::make_unique<TextInputModel>();
1406 model->SetText("ABCDE");
1407 model->BeginComposing();
1408 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
1409 EXPECT_TRUE(model->MoveCursorToBeginning());
1410 EXPECT_EQ(model->selection(), TextRange(1));
1411 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1412 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1413 }

## ◆ TEST() [187/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningReverseSelection |
| ) |  |

Definition at line 1318 of file text_input_model_unittests.cc.

1318 {
1319 auto model = std::make_unique<TextInputModel>();
1320 model->SetText("ABCDE");
1321 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
1322 EXPECT_TRUE(model->MoveCursorToBeginning());
1323 EXPECT_EQ(model->selection(), TextRange(0));
1324 EXPECT_EQ(model->composing_range(), TextRange(0));
1325 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1326 }

## ◆ TEST() [188/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningSelection |
| ) |  |

Definition at line 1298 of file text_input_model_unittests.cc.

1298 {
1299 auto model = std::make_unique<TextInputModel>();
1300 model->SetText("ABCDE");
1301 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
1302 EXPECT_TRUE(model->MoveCursorToBeginning());
1303 EXPECT_EQ(model->selection(), TextRange(0));
1304 EXPECT_EQ(model->composing_range(), TextRange(0));
1305 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1306 }

## ◆ TEST() [189/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningStart |
| ) |  |

Definition at line 1238 of file text_input_model_unittests.cc.

1238 {
1239 auto model = std::make_unique<TextInputModel>();
1240 model->SetText("ABCDE");
1241 EXPECT_TRUE(model->SetSelection(TextRange(0)));
1242 EXPECT_FALSE(model->MoveCursorToBeginning());
1243 EXPECT_EQ(model->selection(), TextRange(0));
1244 EXPECT_EQ(model->composing_range(), TextRange(0));
1245 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1246 }

## ◆ TEST() [190/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningStartComposing |
| ) |  |

Definition at line 1338 of file text_input_model_unittests.cc.

1338 {
1339 auto model = std::make_unique<TextInputModel>();
1340 model->SetText("ABCDE");
1341 model->BeginComposing();
1342 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
1343 EXPECT_FALSE(model->MoveCursorToBeginning());
1344 EXPECT_EQ(model->selection(), TextRange(1));
1345 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1346 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1347 }

## ◆ TEST() [191/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToBeginningStartReverseComposing |
| ) |  |

Definition at line 1360 of file text_input_model_unittests.cc.

1360 {
1361 auto model = std::make_unique<TextInputModel>();
1362 model->SetText("ABCDE");
1363 model->BeginComposing();
1364 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
1365 EXPECT_FALSE(model->MoveCursorToBeginning());
1366 EXPECT_EQ(model->selection(), TextRange(1));
1367 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1368 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1369 }

## ◆ TEST() [192/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndEnd |
| ) |  |

Definition at line 1510 of file text_input_model_unittests.cc.

1510 {
1511 auto model = std::make_unique<TextInputModel>();
1512 model->SetText("ABCDE");
1513 EXPECT_TRUE(model->SetSelection(TextRange(5)));
1514 EXPECT_FALSE(model->MoveCursorToEnd());
1515 EXPECT_EQ(model->selection(), TextRange(5));
1516 EXPECT_EQ(model->composing_range(), TextRange(0));
1517 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1518 }

## ◆ TEST() [193/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndEndComposing |
| ) |  |

Definition at line 1658 of file text_input_model_unittests.cc.

1658 {
1659 auto model = std::make_unique<TextInputModel>();
1660 model->SetText("ABCDE");
1661 model->BeginComposing();
1662 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
1663 EXPECT_FALSE(model->MoveCursorToEnd());
1664 EXPECT_EQ(model->selection(), TextRange(4));
1665 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1666 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1667 }

## ◆ TEST() [194/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndEndReverseComposing |
| ) |  |

Definition at line 1680 of file text_input_model_unittests.cc.

1680 {
1681 auto model = std::make_unique<TextInputModel>();
1682 model->SetText("ABCDE");
1683 model->BeginComposing();
1684 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
1685 EXPECT_FALSE(model->MoveCursorToEnd());
1686 EXPECT_EQ(model->selection(), TextRange(4));
1687 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1688 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1689 }

## ◆ TEST() [195/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndMiddle |
| ) |  |

Definition at line 1490 of file text_input_model_unittests.cc.

1490 {
1491 auto model = std::make_unique<TextInputModel>();
1492 model->SetText("ABCDE");
1493 EXPECT_TRUE(model->SetSelection(TextRange(2)));
1494 EXPECT_TRUE(model->MoveCursorToEnd());
1495 EXPECT_EQ(model->selection(), TextRange(5));
1496 EXPECT_EQ(model->composing_range(), TextRange(0));
1497 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1498 }

## ◆ TEST() [196/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndMiddleComposing |
| ) |  |

Definition at line 1614 of file text_input_model_unittests.cc.

1614 {
1615 auto model = std::make_unique<TextInputModel>();
1616 model->SetText("ABCDE");
1617 model->BeginComposing();
1618 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
1619 EXPECT_TRUE(model->MoveCursorToEnd());
1620 EXPECT_EQ(model->selection(), TextRange(4));
1621 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1622 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1623 }

## ◆ TEST() [197/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndMiddleReverseComposing |
| ) |  |

Definition at line 1636 of file text_input_model_unittests.cc.

1636 {
1637 auto model = std::make_unique<TextInputModel>();
1638 model->SetText("ABCDE");
1639 model->BeginComposing();
1640 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
1641 EXPECT_TRUE(model->MoveCursorToEnd());
1642 EXPECT_EQ(model->selection(), TextRange(4));
1643 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1644 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1645 }

## ◆ TEST() [198/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndReverseSelection |
| ) |  |

Definition at line 1550 of file text_input_model_unittests.cc.

1550 {
1551 auto model = std::make_unique<TextInputModel>();
1552 model->SetText("ABCDE");
1553 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
1554 EXPECT_TRUE(model->MoveCursorToEnd());
1555 EXPECT_EQ(model->selection(), TextRange(5));
1556 EXPECT_EQ(model->composing_range(), TextRange(0));
1557 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1558 }

## ◆ TEST() [199/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndSelection |
| ) |  |

Definition at line 1530 of file text_input_model_unittests.cc.

1530 {
1531 auto model = std::make_unique<TextInputModel>();
1532 model->SetText("ABCDE");
1533 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
1534 EXPECT_TRUE(model->MoveCursorToEnd());
1535 EXPECT_EQ(model->selection(), TextRange(5));
1536 EXPECT_EQ(model->composing_range(), TextRange(0));
1537 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1538 }

## ◆ TEST() [200/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndStart |
| ) |  |

Definition at line 1470 of file text_input_model_unittests.cc.

1470 {
1471 auto model = std::make_unique<TextInputModel>();
1472 model->SetText("ABCDE");
1473 EXPECT_TRUE(model->SetSelection(TextRange(0)));
1474 EXPECT_TRUE(model->MoveCursorToEnd());
1475 EXPECT_EQ(model->selection(), TextRange(5));
1476 EXPECT_EQ(model->composing_range(), TextRange(0));
1477 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1478 }

## ◆ TEST() [201/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndStartComposing |
| ) |  |

Definition at line 1570 of file text_input_model_unittests.cc.

1570 {
1571 auto model = std::make_unique<TextInputModel>();
1572 model->SetText("ABCDE");
1573 model->BeginComposing();
1574 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
1575 EXPECT_TRUE(model->MoveCursorToEnd());
1576 EXPECT_EQ(model->selection(), TextRange(4));
1577 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1578 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1579 }

## ◆ TEST() [202/291]

flutter::TEST | ( | TextInputModel | ,
|  | MoveCursorToEndStartReverseComposing |
| ) |  |

Definition at line 1592 of file text_input_model_unittests.cc.

1592 {
1593 auto model = std::make_unique<TextInputModel>();
1594 model->SetText("ABCDE");
1595 model->BeginComposing();
1596 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
1597 EXPECT_TRUE(model->MoveCursorToEnd());
1598 EXPECT_EQ(model->selection(), TextRange(4));
1599 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1600 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1601 }

## ◆ TEST() [203/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningEnd |
| ) |  |

Definition at line 1288 of file text_input_model_unittests.cc.

1288 {
1289 auto model = std::make_unique<TextInputModel>();
1290 model->SetText("ABCDE");
1291 EXPECT_TRUE(model->SetSelection(TextRange(5)));
1292 EXPECT_TRUE(model->SelectToBeginning());
1293 EXPECT_EQ(model->selection(), TextRange(5, 0));
1294 EXPECT_EQ(model->composing_range(), TextRange(0));
1295 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1296 }

## ◆ TEST() [204/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningEndComposing |
| ) |  |

Definition at line 1437 of file text_input_model_unittests.cc.

1437 {
1438 auto model = std::make_unique<TextInputModel>();
1439 model->SetText("ABCDE");
1440 model->BeginComposing();
1441 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
1442 EXPECT_TRUE(model->MoveCursorToBeginning());
1443 EXPECT_EQ(model->selection(), TextRange(1));
1444 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1445 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1446 }

## ◆ TEST() [205/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningEndReverseComposing |
| ) |  |

Definition at line 1459 of file text_input_model_unittests.cc.

1459 {
1460 auto model = std::make_unique<TextInputModel>();
1461 model->SetText("ABCDE");
1462 model->BeginComposing();
1463 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
1464 EXPECT_TRUE(model->SelectToBeginning());
1465 EXPECT_EQ(model->selection(), TextRange(4, 1));
1466 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1467 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1468 }

## ◆ TEST() [206/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningMiddle |
| ) |  |

Definition at line 1268 of file text_input_model_unittests.cc.

1268 {
1269 auto model = std::make_unique<TextInputModel>();
1270 model->SetText("ABCDE");
1271 EXPECT_TRUE(model->SetSelection(TextRange(2)));
1272 EXPECT_TRUE(model->SelectToBeginning());
1273 EXPECT_EQ(model->selection(), TextRange(2, 0));
1274 EXPECT_EQ(model->composing_range(), TextRange(0));
1275 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1276 }

## ◆ TEST() [207/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningMiddleComposing |
| ) |  |

Definition at line 1393 of file text_input_model_unittests.cc.

1393 {
1394 auto model = std::make_unique<TextInputModel>();
1395 model->SetText("ABCDE");
1396 model->BeginComposing();
1397 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
1398 EXPECT_TRUE(model->SelectToBeginning());
1399 EXPECT_EQ(model->selection(), TextRange(2, 1));
1400 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1401 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1402 }

## ◆ TEST() [208/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningMiddleReverseComposing |
| ) |  |

Definition at line 1415 of file text_input_model_unittests.cc.

1415 {
1416 auto model = std::make_unique<TextInputModel>();
1417 model->SetText("ABCDE");
1418 model->BeginComposing();
1419 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
1420 EXPECT_TRUE(model->SelectToBeginning());
1421 EXPECT_EQ(model->selection(), TextRange(2, 1));
1422 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1423 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1424 }

## ◆ TEST() [209/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningReverseSelection |
| ) |  |

Definition at line 1328 of file text_input_model_unittests.cc.

1328 {
1329 auto model = std::make_unique<TextInputModel>();
1330 model->SetText("ABCDE");
1331 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
1332 EXPECT_TRUE(model->SelectToBeginning());
1333 EXPECT_EQ(model->selection(), TextRange(4, 0));
1334 EXPECT_EQ(model->composing_range(), TextRange(0));
1335 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1336 }

## ◆ TEST() [210/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningSelection |
| ) |  |

Definition at line 1308 of file text_input_model_unittests.cc.

1308 {
1309 auto model = std::make_unique<TextInputModel>();
1310 model->SetText("ABCDE");
1311 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
1312 EXPECT_TRUE(model->SelectToBeginning());
1313 EXPECT_EQ(model->selection(), TextRange(1, 0));
1314 EXPECT_EQ(model->composing_range(), TextRange(0));
1315 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1316 }

## ◆ TEST() [211/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningStart |
| ) |  |

Definition at line 1248 of file text_input_model_unittests.cc.

1248 {
1249 auto model = std::make_unique<TextInputModel>();
1250 model->SetText("ABCDE");
1251 EXPECT_TRUE(model->SetSelection(TextRange(0)));
1252 EXPECT_FALSE(model->SelectToBeginning());
1253 EXPECT_EQ(model->selection(), TextRange(0));
1254 EXPECT_EQ(model->composing_range(), TextRange(0));
1255 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1256 }

## ◆ TEST() [212/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningStartComposing |
| ) |  |

Definition at line 1349 of file text_input_model_unittests.cc.

1349 {
1350 auto model = std::make_unique<TextInputModel>();
1351 model->SetText("ABCDE");
1352 model->BeginComposing();
1353 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
1354 EXPECT_FALSE(model->SelectToBeginning());
1355 EXPECT_EQ(model->selection(), TextRange(1));
1356 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1357 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1358 }

## ◆ TEST() [213/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToBeginningStartReverseComposing |
| ) |  |

Definition at line 1371 of file text_input_model_unittests.cc.

1371 {
1372 auto model = std::make_unique<TextInputModel>();
1373 model->SetText("ABCDE");
1374 model->BeginComposing();
1375 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 0));
1376 EXPECT_FALSE(model->SelectToBeginning());
1377 EXPECT_EQ(model->selection(), TextRange(1));
1378 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1379 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1380 }

## ◆ TEST() [214/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndEnd |
| ) |  |

Definition at line 1520 of file text_input_model_unittests.cc.

1520 {
1521 auto model = std::make_unique<TextInputModel>();
1522 model->SetText("ABCDE");
1523 EXPECT_TRUE(model->SetSelection(TextRange(5)));
1524 EXPECT_FALSE(model->SelectToEnd());
1525 EXPECT_EQ(model->selection(), TextRange(5));
1526 EXPECT_EQ(model->composing_range(), TextRange(0));
1527 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1528 }

## ◆ TEST() [215/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndEndComposing |
| ) |  |

Definition at line 1669 of file text_input_model_unittests.cc.

1669 {
1670 auto model = std::make_unique<TextInputModel>();
1671 model->SetText("ABCDE");
1672 model->BeginComposing();
1673 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
1674 EXPECT_FALSE(model->SelectToEnd());
1675 EXPECT_EQ(model->selection(), TextRange(4));
1676 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1677 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1678 }

## ◆ TEST() [216/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndEndReverseComposing |
| ) |  |

Definition at line 1691 of file text_input_model_unittests.cc.

1691 {
1692 auto model = std::make_unique<TextInputModel>();
1693 model->SetText("ABCDE");
1694 model->BeginComposing();
1695 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
1696 EXPECT_FALSE(model->SelectToEnd());
1697 EXPECT_EQ(model->selection(), TextRange(4));
1698 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1699 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1700 }

## ◆ TEST() [217/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndMiddle |
| ) |  |

Definition at line 1500 of file text_input_model_unittests.cc.

1500 {
1501 auto model = std::make_unique<TextInputModel>();
1502 model->SetText("ABCDE");
1503 EXPECT_TRUE(model->SetSelection(TextRange(2)));
1504 EXPECT_TRUE(model->SelectToEnd());
1505 EXPECT_EQ(model->selection(), TextRange(2, 5));
1506 EXPECT_EQ(model->composing_range(), TextRange(0));
1507 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1508 }

## ◆ TEST() [218/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndMiddleComposing |
| ) |  |

Definition at line 1625 of file text_input_model_unittests.cc.

1625 {
1626 auto model = std::make_unique<TextInputModel>();
1627 model->SetText("ABCDE");
1628 model->BeginComposing();
1629 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 1));
1630 EXPECT_TRUE(model->SelectToEnd());
1631 EXPECT_EQ(model->selection(), TextRange(2, 4));
1632 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1633 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1634 }

## ◆ TEST() [219/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndMiddleReverseComposing |
| ) |  |

Definition at line 1647 of file text_input_model_unittests.cc.

1647 {
1648 auto model = std::make_unique<TextInputModel>();
1649 model->SetText("ABCDE");
1650 model->BeginComposing();
1651 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 1));
1652 EXPECT_TRUE(model->SelectToEnd());
1653 EXPECT_EQ(model->selection(), TextRange(2, 4));
1654 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
1655 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1656 }

## ◆ TEST() [220/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndReverseSelection |
| ) |  |

Definition at line 1560 of file text_input_model_unittests.cc.

1560 {
1561 auto model = std::make_unique<TextInputModel>();
1562 model->SetText("ABCDE");
1563 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
1564 EXPECT_TRUE(model->SelectToEnd());
1565 EXPECT_EQ(model->selection(), TextRange(4, 5));
1566 EXPECT_EQ(model->composing_range(), TextRange(0));
1567 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1568 }

## ◆ TEST() [221/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndSelection |
| ) |  |

Definition at line 1540 of file text_input_model_unittests.cc.

1540 {
1541 auto model = std::make_unique<TextInputModel>();
1542 model->SetText("ABCDE");
1543 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
1544 EXPECT_TRUE(model->SelectToEnd());
1545 EXPECT_EQ(model->selection(), TextRange(1, 5));
1546 EXPECT_EQ(model->composing_range(), TextRange(0));
1547 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1548 }

## ◆ TEST() [222/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndStart |
| ) |  |

Definition at line 1480 of file text_input_model_unittests.cc.

1480 {
1481 auto model = std::make_unique<TextInputModel>();
1482 model->SetText("ABCDE");
1483 EXPECT_TRUE(model->SetSelection(TextRange(0)));
1484 EXPECT_TRUE(model->SelectToEnd());
1485 EXPECT_EQ(model->selection(), TextRange(0, 5));
1486 EXPECT_EQ(model->composing_range(), TextRange(0));
1487 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1488 }

## ◆ TEST() [223/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndStartComposing |
| ) |  |

Definition at line 1581 of file text_input_model_unittests.cc.

1581 {
1582 auto model = std::make_unique<TextInputModel>();
1583 model->SetText("ABCDE");
1584 model->BeginComposing();
1585 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
1586 EXPECT_TRUE(model->SelectToEnd());
1587 EXPECT_EQ(model->selection(), TextRange(1, 4));
1588 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1589 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1590 }

## ◆ TEST() [224/291]

flutter::TEST | ( | TextInputModel | ,
|  | SelectToEndStartReverseComposing |
| ) |  |

Definition at line 1603 of file text_input_model_unittests.cc.

1603 {
1604 auto model = std::make_unique<TextInputModel>();
1605 model->SetText("ABCDE");
1606 model->BeginComposing();
1607 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
1608 EXPECT_TRUE(model->SelectToEnd());
1609 EXPECT_EQ(model->selection(), TextRange(1, 4));
1610 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
1611 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
1612 }

## ◆ TEST() [225/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetComposingRangeEnd |
| ) |  |

Definition at line 190 of file text_input_model_unittests.cc.

190 {
191 auto model = std::make_unique<TextInputModel>();
192 model->SetText("ABCDE");
193 model->BeginComposing();
194 EXPECT_TRUE(model->SetComposingRange(TextRange(5, 5), 0));
195 EXPECT_EQ(model->selection(), TextRange(5));
196 EXPECT_EQ(model->composing_range(), TextRange(5));
197 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
198 }

## ◆ TEST() [226/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetComposingRangeMiddle |
| ) |  |

Definition at line 180 of file text_input_model_unittests.cc.

180 {
181 auto model = std::make_unique<TextInputModel>();
182 model->SetText("ABCDE");
183 model->BeginComposing();
184 EXPECT_TRUE(model->SetComposingRange(TextRange(2, 2), 0));
185 EXPECT_EQ(model->selection(), TextRange(2));
186 EXPECT_EQ(model->composing_range(), TextRange(2));
187 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
188 }

## ◆ TEST() [227/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetComposingRangeOutsideString |
| ) |  |

Definition at line 220 of file text_input_model_unittests.cc.

220 {
221 auto model = std::make_unique<TextInputModel>();
222 model->SetText("ABCDE");
223 model->BeginComposing();
224 EXPECT_FALSE(model->SetComposingRange(TextRange(4, 6), 0));
225 EXPECT_FALSE(model->SetComposingRange(TextRange(5, 6), 0));
226 EXPECT_FALSE(model->SetComposingRange(TextRange(6, 6), 0));
227 }

## ◆ TEST() [228/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetComposingRangeReverseExtent |
| ) |  |

Definition at line 210 of file text_input_model_unittests.cc.

210 {
211 auto model = std::make_unique<TextInputModel>();
212 model->SetText("ABCDE");
213 model->BeginComposing();
214 EXPECT_TRUE(model->SetComposingRange(TextRange(4, 1), 3));
215 EXPECT_EQ(model->selection(), TextRange(4));
216 EXPECT_EQ(model->composing_range(), TextRange(4, 1));
217 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
218 }

## ◆ TEST() [229/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetComposingRangeStart |
| ) |  |

Definition at line 170 of file text_input_model_unittests.cc.

170 {
171 auto model = std::make_unique<TextInputModel>();
172 model->SetText("ABCDE");
173 model->BeginComposing();
174 EXPECT_TRUE(model->SetComposingRange(TextRange(0, 0), 0));
175 EXPECT_EQ(model->selection(), TextRange(0));
176 EXPECT_EQ(model->composing_range(), TextRange(0));
177 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
178 }

## ◆ TEST() [230/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetComposingRangeWithExtent |
| ) |  |

Definition at line 200 of file text_input_model_unittests.cc.

200 {
201 auto model = std::make_unique<TextInputModel>();
202 model->SetText("ABCDE");
203 model->BeginComposing();
204 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 3));
205 EXPECT_EQ(model->selection(), TextRange(4));
206 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
207 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
208 }

## ◆ TEST() [231/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionComposingEnd |
| ) |  |

Definition at line 99 of file text_input_model_unittests.cc.

99 {
100 auto model = std::make_unique<TextInputModel>();
101 model->SetText("ABCDE");
102 model->BeginComposing();
103 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
104 EXPECT_TRUE(model->SetSelection(TextRange(4)));
105 EXPECT_EQ(model->selection(), TextRange(4));
106 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
107 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
108 }

## ◆ TEST() [232/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionComposingMiddle |
| ) |  |

Definition at line 79 of file text_input_model_unittests.cc.

79 {
80 auto model = std::make_unique<TextInputModel>();
81 model->SetText("ABCDE");
82 model->BeginComposing();
83 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
84 EXPECT_TRUE(model->SetSelection(TextRange(2)));
85 EXPECT_EQ(model->selection(), TextRange(2));
86 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
87 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
88 }

## ◆ TEST() [233/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionComposingStart |
| ) |  |

Definition at line 59 of file text_input_model_unittests.cc.

59 {
60 auto model = std::make_unique<TextInputModel>();
61 model->SetText("ABCDE");
62 model->BeginComposing();
63 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
64 EXPECT_TRUE(model->SetSelection(TextRange(1)));
65 EXPECT_EQ(model->selection(), TextRange(1));
66 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
67 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
68 }

## ◆ TEST() [234/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionEnd |
| ) |  |

Definition at line 90 of file text_input_model_unittests.cc.

90 {
91 auto model = std::make_unique<TextInputModel>();
92 model->SetText("ABCDE");
93 EXPECT_TRUE(model->SetSelection(TextRange(5)));
94 EXPECT_EQ(model->selection(), TextRange(5));
95 EXPECT_EQ(model->composing_range(), TextRange(0));
96 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
97 }

## ◆ TEST() [235/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionMiddle |
| ) |  |

Definition at line 70 of file text_input_model_unittests.cc.

70 {
71 auto model = std::make_unique<TextInputModel>();
72 model->SetText("ABCDE");
73 EXPECT_TRUE(model->SetSelection(TextRange(2)));
74 EXPECT_EQ(model->selection(), TextRange(2));
75 EXPECT_EQ(model->composing_range(), TextRange(0));
76 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
77 }

## ◆ TEST() [236/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionOutsideComposingRange |
| ) |  |

Definition at line 158 of file text_input_model_unittests.cc.

158 {
159 auto model = std::make_unique<TextInputModel>();
160 model->SetText("ABCDE");
161 model->BeginComposing();
162 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
163 EXPECT_FALSE(model->SetSelection(TextRange(0)));
164 EXPECT_EQ(model->selection(), TextRange(1));
165 EXPECT_FALSE(model->SetSelection(TextRange(5)));
166 EXPECT_EQ(model->selection(), TextRange(1));
167 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
168 }

## ◆ TEST() [237/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionOutsideString |
| ) |  |

Definition at line 150 of file text_input_model_unittests.cc.

150 {
151 auto model = std::make_unique<TextInputModel>();
152 model->SetText("ABCDE");
153 EXPECT_FALSE(model->SetSelection(TextRange(4, 6)));
154 EXPECT_FALSE(model->SetSelection(TextRange(5, 6)));
155 EXPECT_FALSE(model->SetSelection(TextRange(6)));
156 }

## ◆ TEST() [238/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionReverseExtent |
| ) |  |

Definition at line 130 of file text_input_model_unittests.cc.

130 {
131 auto model = std::make_unique<TextInputModel>();
132 model->SetText("ABCDE");
133 EXPECT_TRUE(model->SetSelection(TextRange(4, 1)));
134 EXPECT_EQ(model->selection(), TextRange(4, 1));
135 EXPECT_EQ(model->composing_range(), TextRange(0));
136 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
137 }

## ◆ TEST() [239/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionReverseExtentComposing |
| ) |  |

Definition at line 139 of file text_input_model_unittests.cc.

139 {
140 auto model = std::make_unique<TextInputModel>();
141 model->SetText("ABCDE");
142 model->BeginComposing();
143 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
144 EXPECT_FALSE(model->SetSelection(TextRange(4, 1)));
145 EXPECT_EQ(model->selection(), TextRange(1));
146 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
147 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
148 }

## ◆ TEST() [240/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionStart |
| ) |  |

Definition at line 50 of file text_input_model_unittests.cc.

50 {
51 auto model = std::make_unique<TextInputModel>();
52 model->SetText("ABCDE");
53 EXPECT_TRUE(model->SetSelection(TextRange(0)));
54 EXPECT_EQ(model->selection(), TextRange(0));
55 EXPECT_EQ(model->composing_range(), TextRange(0));
56 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
57 }

## ◆ TEST() [241/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionWthExtent |
| ) |  |

Definition at line 110 of file text_input_model_unittests.cc.

110 {
111 auto model = std::make_unique<TextInputModel>();
112 model->SetText("ABCDE");
113 EXPECT_TRUE(model->SetSelection(TextRange(1, 4)));
114 EXPECT_EQ(model->selection(), TextRange(1, 4));
115 EXPECT_EQ(model->composing_range(), TextRange(0));
116 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
117 }

## ◆ TEST() [242/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetSelectionWthExtentComposing |
| ) |  |

Definition at line 119 of file text_input_model_unittests.cc.

119 {
120 auto model = std::make_unique<TextInputModel>();
121 model->SetText("ABCDE");
122 model->BeginComposing();
123 EXPECT_TRUE(model->SetComposingRange(TextRange(1, 4), 0));
124 EXPECT_FALSE(model->SetSelection(TextRange(1, 4)));
125 EXPECT_EQ(model->selection(), TextRange(1));
126 EXPECT_EQ(model->composing_range(), TextRange(1, 4));
127 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
128 }

## ◆ TEST() [243/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetText |
| ) |  |

Definition at line 15 of file text_input_model_unittests.cc.

15 {
16 auto model = std::make_unique<TextInputModel>();
17 model->SetText("ABCDE");
18 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
19 }

## ◆ TEST() [244/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetTextEmpty |
| ) |  |

Definition at line 27 of file text_input_model_unittests.cc.

27 {
28 auto model = std::make_unique<TextInputModel>();
29 model->SetText("");
30 EXPECT_STREQ(model->GetText().c_str(), "");
31 }

## ◆ TEST() [245/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetTextReplaceText |
| ) |  |

Definition at line 33 of file text_input_model_unittests.cc.

33 {
34 auto model = std::make_unique<TextInputModel>();
35 model->SetText("ABCDE");
36 EXPECT_STREQ(model->GetText().c_str(), "ABCDE");
37 model->SetText("");
38 EXPECT_STREQ(model->GetText().c_str(), "");
39 }

## ◆ TEST() [246/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetTextResetsSelection |
| ) |  |

Definition at line 41 of file text_input_model_unittests.cc.

41 {
42 auto model = std::make_unique<TextInputModel>();
43 model->SetText("ABCDE");
44 EXPECT_TRUE(model->SetSelection(TextRange(3)));
45 EXPECT_EQ(model->selection(), TextRange(3));
46 model->SetText("FGHJI");
47 EXPECT_EQ(model->selection(), TextRange(0));
48 }

## ◆ TEST() [247/291]

flutter::TEST | ( | TextInputModel | ,
|  | SetTextWideCharacters |
| ) |  |

Definition at line 21 of file text_input_model_unittests.cc.

21 {
22 auto model = std::make_unique<TextInputModel>();
23 model->SetText("😄🙃🤪🧐");
24 EXPECT_STREQ(model->GetText().c_str(), "😄🙃🤪🧐");
25 }

## ◆ TEST() [248/291]

flutter::TEST | ( | TextInputModel | ,
|  | UpdateComposingRemovesLastComposingCharacter |
| ) |  |

Definition at line 395 of file text_input_model_unittests.cc.

395 {
396 auto model = std::make_unique<TextInputModel>();
397 model->SetText("ABCDE");
398 model->BeginComposing();
399 model->SetComposingRange(TextRange(1, 2), 1);
400 model->UpdateComposingText("");
401 EXPECT_EQ(model->selection(), TextRange(1));
402 EXPECT_EQ(model->composing_range(), TextRange(1));
403 model->SetText("ACDE");
404 }

## ◆ TEST() [249/291]

flutter::TEST | ( | TextInputModel | ,
|  | UpdateSelectionWhileComposing |
| ) |  |

Definition at line 406 of file text_input_model_unittests.cc.

406 {
407 auto model = std::make_unique<TextInputModel>();
408 model->SetText("ABCDE");
409 model->BeginComposing();
410 model->SetComposingRange(TextRange(4, 5), 1);
411 model->UpdateComposingText(u"ぴょんぴょん", TextRange(3, 6));
412 EXPECT_STREQ(model->GetText().c_str(), "ABCDぴょんぴょん");
413 EXPECT_EQ(model->selection(), TextRange(7, 10));
414 EXPECT_EQ(model->composing_range(), TextRange(4, 10));
415 }

## ◆ TEST() [250/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsEndPosition |
| ) |  |

Definition at line 125 of file text_range_unittests.cc.

125 {
126 TextRange range(2, 6);
127 EXPECT_TRUE(range.Contains(6));
128 }

References flutter::TextRange::Contains().

## ◆ TEST() [251/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsEndPositionReversed |
| ) |  |

Definition at line 151 of file text_range_unittests.cc.

151 {
152 TextRange range(6, 2);
153 EXPECT_TRUE(range.Contains(6));
154 }

References flutter::TextRange::Contains().

## ◆ TEST() [252/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsMiddlePosition |
| ) |  |

Definition at line 119 of file text_range_unittests.cc.

119 {
120 TextRange range(2, 6);
121 EXPECT_TRUE(range.Contains(3));
122 EXPECT_TRUE(range.Contains(4));
123 }

References flutter::TextRange::Contains().

## ◆ TEST() [253/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsMiddlePositionReversed |
| ) |  |

Definition at line 145 of file text_range_unittests.cc.

145 {
146 TextRange range(6, 2);
147 EXPECT_TRUE(range.Contains(3));
148 EXPECT_TRUE(range.Contains(4));
149 }

References flutter::TextRange::Contains().

## ◆ TEST() [254/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsPostEndPosition |
| ) |  |

Definition at line 130 of file text_range_unittests.cc.

130 {
131 TextRange range(2, 6);
132 EXPECT_FALSE(range.Contains(7));
133 }

References flutter::TextRange::Contains().

## ◆ TEST() [255/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsPostEndPositionReversed |
| ) |  |

Definition at line 156 of file text_range_unittests.cc.

156 {
157 TextRange range(6, 2);
158 EXPECT_FALSE(range.Contains(7));
159 }

References flutter::TextRange::Contains().

## ◆ TEST() [256/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsPreStartPosition |
| ) |  |

Definition at line 109 of file text_range_unittests.cc.

109 {
110 TextRange range(2, 6);
111 EXPECT_FALSE(range.Contains(1));
112 }

References flutter::TextRange::Contains().

## ◆ TEST() [257/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsPreStartPositionReversed |
| ) |  |

Definition at line 135 of file text_range_unittests.cc.

135 {
136 TextRange range(6, 2);
137 EXPECT_FALSE(range.Contains(1));
138 }

References flutter::TextRange::Contains().

## ◆ TEST() [258/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeEndPosition |
| ) |  |

Definition at line 182 of file text_range_unittests.cc.

182 {
183 TextRange range(2, 6);
184 EXPECT_TRUE(range.Contains(TextRange(6)));
185 }

References flutter::TextRange::Contains().

## ◆ TEST() [259/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeEndPositionReversed |
| ) |  |

Definition at line 223 of file text_range_unittests.cc.

223 {
224 TextRange range(6, 2);
225 EXPECT_TRUE(range.Contains(TextRange(5)));
226 }

References flutter::TextRange::Contains().

## ◆ TEST() [260/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeMiddlePosition |
| ) |  |

Definition at line 176 of file text_range_unittests.cc.

176 {
177 TextRange range(2, 6);
178 EXPECT_TRUE(range.Contains(TextRange(3, 4)));
179 EXPECT_TRUE(range.Contains(TextRange(4, 5)));
180 }

References flutter::TextRange::Contains().

## ◆ TEST() [261/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeMiddlePositionReversed |
| ) |  |

Definition at line 212 of file text_range_unittests.cc.

212 {
213 TextRange range(6, 2);
214 EXPECT_TRUE(range.Contains(TextRange(3, 4)));
215 EXPECT_TRUE(range.Contains(TextRange(4, 5)));
216 }

References flutter::TextRange::Contains().

## ◆ TEST() [262/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangePostEndPosition |
| ) |  |

Definition at line 192 of file text_range_unittests.cc.

192 {
193 TextRange range(2, 6);
194 EXPECT_FALSE(range.Contains(TextRange(6, 7)));
195 }

References flutter::TextRange::Contains().

## ◆ TEST() [263/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangePostEndPositionReversed |
| ) |  |

Definition at line 228 of file text_range_unittests.cc.

228 {
229 TextRange range(6, 2);
230 EXPECT_FALSE(range.Contains(TextRange(6, 7)));
231 }

References flutter::TextRange::Contains().

## ◆ TEST() [264/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangePreStartPosition |
| ) |  |

Definition at line 161 of file text_range_unittests.cc.

161 {
162 TextRange range(2, 6);
163 EXPECT_FALSE(range.Contains(TextRange(0, 1)));
164 }

References flutter::TextRange::Contains().

## ◆ TEST() [265/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangePreStartPositionReversed |
| ) |  |

Definition at line 197 of file text_range_unittests.cc.

197 {
198 TextRange range(6, 2);
199 EXPECT_FALSE(range.Contains(TextRange(0, 1)));
200 }

References flutter::TextRange::Contains().

## ◆ TEST() [266/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeSpanningEndPosition |
| ) |  |

Definition at line 187 of file text_range_unittests.cc.

187 {
188 TextRange range(2, 6);
189 EXPECT_FALSE(range.Contains(TextRange(5, 7)));
190 }

References flutter::TextRange::Contains().

## ◆ TEST() [267/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeSpanningEndPositionReversed |
| ) |  |

Definition at line 218 of file text_range_unittests.cc.

218 {
219 TextRange range(6, 2);
220 EXPECT_FALSE(range.Contains(TextRange(5, 7)));
221 }

References flutter::TextRange::Contains().

## ◆ TEST() [268/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeSpanningStartPosition |
| ) |  |

Definition at line 166 of file text_range_unittests.cc.

166 {
167 TextRange range(2, 6);
168 EXPECT_FALSE(range.Contains(TextRange(1, 3)));
169 }

References flutter::TextRange::Contains().

## ◆ TEST() [269/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeSpanningStartPositionReversed |
| ) |  |

Definition at line 202 of file text_range_unittests.cc.

202 {
203 TextRange range(6, 2);
204 EXPECT_FALSE(range.Contains(TextRange(1, 3)));
205 }

References flutter::TextRange::Contains().

## ◆ TEST() [270/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeStartPosition |
| ) |  |

Definition at line 171 of file text_range_unittests.cc.

171 {
172 TextRange range(2, 6);
173 EXPECT_TRUE(range.Contains(TextRange(2)));
174 }

References flutter::TextRange::Contains().

## ◆ TEST() [271/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsRangeStartPositionReversed |
| ) |  |

Definition at line 207 of file text_range_unittests.cc.

207 {
208 TextRange range(6, 2);
209 EXPECT_TRUE(range.Contains(TextRange(2)));
210 }

References flutter::TextRange::Contains().

## ◆ TEST() [272/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsStartPosition |
| ) |  |

Definition at line 114 of file text_range_unittests.cc.

114 {
115 TextRange range(2, 6);
116 EXPECT_TRUE(range.Contains(2));
117 }

References flutter::TextRange::Contains().

## ◆ TEST() [273/291]

flutter::TEST | ( | TextRange | ,
|  | ContainsStartPositionReversed |
| ) |  |

Definition at line 140 of file text_range_unittests.cc.

140 {
141 TextRange range(6, 2);
142 EXPECT_TRUE(range.Contains(2));
143 }

References flutter::TextRange::Contains().

## ◆ TEST() [274/291]

flutter::TEST | ( | TextRange | ,
|  | ReversedCollapsedRange |
| ) |  |

Definition at line 238 of file text_range_unittests.cc.

238 {
239 TextRange range(2, 2);
240 EXPECT_FALSE(range.reversed());
241 }

References flutter::TextRange::reversed().

## ◆ TEST() [275/291]

flutter::TEST | ( | TextRange | ,
|  | ReversedForwardRange |
| ) |  |

Definition at line 233 of file text_range_unittests.cc.

233 {
234 TextRange range(2, 6);
235 EXPECT_FALSE(range.reversed());
236 }

References flutter::TextRange::reversed().

## ◆ TEST() [276/291]

flutter::TEST | ( | TextRange | ,
|  | ReversedReversedRange |
| ) |  |

Definition at line 243 of file text_range_unittests.cc.

243 {
244 TextRange range(6, 2);
245 EXPECT_TRUE(range.reversed());
246 }

References flutter::TextRange::reversed().

## ◆ TEST() [277/291]

flutter::TEST | ( | TextRange | ,
|  | SetBase |
| ) |  |

Definition at line 53 of file text_range_unittests.cc.

53 {
54 TextRange range(3, 7);
55 range.set_base(4);
56 EXPECT_EQ(range.base(), size_t(4));
57 EXPECT_EQ(range.extent(), size_t(7));
58 }

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_base().

## ◆ TEST() [278/291]

flutter::TEST | ( | TextRange | ,
|  | SetBaseReversed |
| ) |  |

Definition at line 60 of file text_range_unittests.cc.

60 {
61 TextRange range(7, 3);
62 range.set_base(5);
63 EXPECT_EQ(range.base(), size_t(5));
64 EXPECT_EQ(range.extent(), size_t(3));
65 }

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_base().

## ◆ TEST() [279/291]

flutter::TEST | ( | TextRange | ,
|  | SetEnd |
| ) |  |

Definition at line 95 of file text_range_unittests.cc.

95 {
96 TextRange range(3, 7);
97 range.set_end(6);
98 EXPECT_EQ(range.base(), size_t(3));
99 EXPECT_EQ(range.extent(), size_t(6));
100 }

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_end().

## ◆ TEST() [280/291]

flutter::TEST | ( | TextRange | ,
|  | SetEndReversed |
| ) |  |

Definition at line 102 of file text_range_unittests.cc.

102 {
103 TextRange range(7, 3);
104 range.set_end(5);
105 EXPECT_EQ(range.base(), size_t(5));
106 EXPECT_EQ(range.extent(), size_t(3));
107 }

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_end().

## ◆ TEST() [281/291]

flutter::TEST | ( | TextRange | ,
|  | SetExtent |
| ) |  |

Definition at line 67 of file text_range_unittests.cc.

67 {
68 TextRange range(3, 7);
69 range.set_extent(6);
70 EXPECT_EQ(range.base(), size_t(3));
71 EXPECT_EQ(range.extent(), size_t(6));
72 }

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_extent().

## ◆ TEST() [282/291]

flutter::TEST | ( | TextRange | ,
|  | SetExtentReversed |
| ) |  |

Definition at line 74 of file text_range_unittests.cc.

74 {
75 TextRange range(7, 3);
76 range.set_extent(4);
77 EXPECT_EQ(range.base(), size_t(7));
78 EXPECT_EQ(range.extent(), size_t(4));
79 }

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_extent().

## ◆ TEST() [283/291]

flutter::TEST | ( | TextRange | ,
|  | SetStart |
| ) |  |

Definition at line 81 of file text_range_unittests.cc.

81 {
82 TextRange range(3, 7);
83 range.set_start(5);
84 EXPECT_EQ(range.base(), size_t(5));
85 EXPECT_EQ(range.extent(), size_t(7));
86 }

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_start().

## ◆ TEST() [284/291]

flutter::TEST | ( | TextRange | ,
|  | SetStartReversed |
| ) |  |

Definition at line 88 of file text_range_unittests.cc.

88 {
89 TextRange range(7, 3);
90 range.set_start(5);
91 EXPECT_EQ(range.base(), size_t(7));
92 EXPECT_EQ(range.extent(), size_t(5));
93 }

References flutter::TextRange::base(), flutter::TextRange::extent(), and flutter::TextRange::set_start().

## ◆ TEST() [285/291]

flutter::TEST | ( | TextRange | ,
|  | TextRangeFromPositionNonZero |
| ) |  |

Definition at line 22 of file text_range_unittests.cc.

22 {
23 TextRange range(3);
24 EXPECT_EQ(range.base(), size_t(3));
25 EXPECT_EQ(range.extent(), size_t(3));
26 EXPECT_EQ(range.start(), size_t(3));
27 EXPECT_EQ(range.end(), size_t(3));
28 EXPECT_EQ(range.length(), size_t(0));
29 EXPECT_EQ(range.position(), size_t(3));
30 EXPECT_TRUE(range.collapsed());
31 }

References flutter::TextRange::base(), flutter::TextRange::collapsed(), flutter::TextRange::end(), flutter::TextRange::extent(), flutter::TextRange::length(), flutter::TextRange::position(), and flutter::TextRange::start().

## ◆ TEST() [286/291]

flutter::TEST | ( | TextRange | ,
|  | TextRangeFromPositionZero |
| ) |  |

Definition at line 11 of file text_range_unittests.cc.

11 {
12 TextRange range(0);
13 EXPECT_EQ(range.base(), size_t(0));
14 EXPECT_EQ(range.extent(), size_t(0));
15 EXPECT_EQ(range.start(), size_t(0));
16 EXPECT_EQ(range.end(), size_t(0));
17 EXPECT_EQ(range.length(), size_t(0));
18 EXPECT_EQ(range.position(), size_t(0));
19 EXPECT_TRUE(range.collapsed());
20 }

References flutter::TextRange::base(), flutter::TextRange::collapsed(), flutter::TextRange::end(), flutter::TextRange::extent(), flutter::TextRange::length(), flutter::TextRange::position(), and flutter::TextRange::start().

## ◆ TEST() [287/291]

flutter::TEST | ( | TextRange | ,
|  | TextRangeFromRange |
| ) |  |

Definition at line 33 of file text_range_unittests.cc.

33 {
34 TextRange range(3, 7);
35 EXPECT_EQ(range.base(), size_t(3));
36 EXPECT_EQ(range.extent(), size_t(7));
37 EXPECT_EQ(range.start(), size_t(3));
38 EXPECT_EQ(range.end(), size_t(7));
39 EXPECT_EQ(range.length(), size_t(4));
40 EXPECT_FALSE(range.collapsed());
41 }

References flutter::TextRange::base(), flutter::TextRange::collapsed(), flutter::TextRange::end(), flutter::TextRange::extent(), flutter::TextRange::length(), and flutter::TextRange::start().

## ◆ TEST() [288/291]

flutter::TEST | ( | TextRange | ,
|  | TextRangeFromReversedRange |
| ) |  |

Definition at line 43 of file text_range_unittests.cc.

43 {
44 TextRange range(7, 3);
45 EXPECT_EQ(range.base(), size_t(7));
46 EXPECT_EQ(range.extent(), size_t(3));
47 EXPECT_EQ(range.start(), size_t(3));
48 EXPECT_EQ(range.end(), size_t(7));
49 EXPECT_EQ(range.length(), size_t(4));
50 EXPECT_FALSE(range.collapsed());
51 }

References flutter::TextRange::base(), flutter::TextRange::collapsed(), flutter::TextRange::end(), flutter::TextRange::extent(), flutter::TextRange::length(), and flutter::TextRange::start().

## ◆ TEST() [289/291]

flutter::TEST | ( | TextureRegistrarTest | ,
|  | MarkFrameAvailableInvalidTexture |
| ) |  |

Definition at line 143 of file texture_registrar_unittests.cc.

143 {
144 auto dummy_registrar_handle =
145 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
146 PluginRegistrar registrar(dummy_registrar_handle);
147
148 TextureRegistrar* textures = registrar.texture_registrar();
149
150 bool success = textures->MarkTextureFrameAvailable(42);
151 EXPECT_FALSE(success);
152 }

References flutter::TextureRegistrar::MarkTextureFrameAvailable(), and flutter::PluginRegistrar::texture_registrar().

## ◆ TEST() [290/291]

flutter::TEST | ( | TextureRegistrarTest | ,
|  | RegisterUnregisterTexture |
| ) |  |

Definition at line 87 of file texture_registrar_unittests.cc.

87 {
88 testing::ScopedStubFlutterApi scoped_api_stub(std::make_unique<TestApi>());
89 auto test_api = static_cast<TestApi*>(scoped_api_stub.stub());
90
91 auto dummy_registrar_handle =
92 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
93 PluginRegistrar registrar(dummy_registrar_handle);
94 TextureRegistrar* textures = registrar.texture_registrar();
95 ASSERT_NE(textures, nullptr);
96
97 EXPECT_EQ(test_api->last_texture_id(), -1);
98 auto texture = test_api->GetFakeTexture(0);
99 EXPECT_EQ(texture, nullptr);
100
101 auto pixel_buffer_texture = std::make_unique<TextureVariant>(
102 PixelBufferTexture([](size_t width, size_t height) { return nullptr; }));
103 int64_t texture_id = textures->RegisterTexture(pixel_buffer_texture.get());
104 EXPECT_EQ(test_api->last_texture_id(), texture_id);
105 EXPECT_EQ(test_api->textures_size(), static_cast<size_t>(1));
106
107 texture = test_api->GetFakeTexture(texture_id);
108 EXPECT_EQ(texture->texture_id, texture_id);
109 EXPECT_EQ(texture->user_data,
110 std::get_if<PixelBufferTexture>(pixel_buffer_texture.get()));
111
112 textures->MarkTextureFrameAvailable(texture_id);
113 textures->MarkTextureFrameAvailable(texture_id);
114 bool success = textures->MarkTextureFrameAvailable(texture_id);
115 EXPECT_TRUE(success);
116 EXPECT_EQ(texture->mark_count, 3);
117
118 fml::AutoResetWaitableEvent unregister_latch;
119 textures->UnregisterTexture(texture_id, [&]() { unregister_latch.Signal(); });
120 unregister_latch.Wait();
121
122 texture = test_api->GetFakeTexture(texture_id);
123 EXPECT_EQ(texture, nullptr);
124 EXPECT_EQ(test_api->textures_size(), static_cast<size_t>(0));
125 }
height
self height
Definition: fl_compositor_software.cc:43
width
self width
Definition: fl_compositor_software.cc:42
texture_id
int64_t texture_id
Definition: texture_registrar_unittests.cc:24

References height, flutter::TextureRegistrar::MarkTextureFrameAvailable(), flutter::TextureRegistrar::RegisterTexture(), texture_id, flutter::PluginRegistrar::texture_registrar(), flutter::TextureRegistrar::UnregisterTexture(), and width.

## ◆ TEST() [291/291]

flutter::TEST | ( | TextureRegistrarTest | ,
|  | UnregisterInvalidTexture |
| ) |  |

Definition at line 129 of file texture_registrar_unittests.cc.

129 {
130 auto dummy_registrar_handle =
131 reinterpret_cast<FlutterDesktopPluginRegistrarRef>(1);
132 PluginRegistrar registrar(dummy_registrar_handle);
133
134 TextureRegistrar* textures = registrar.texture_registrar();
135
136 fml::AutoResetWaitableEvent latch;
137 textures->UnregisterTexture(42, [&]() { latch.Signal(); });
138 latch.Wait();
139 }

References flutter::PluginRegistrar::texture_registrar(), and flutter::TextureRegistrar::UnregisterTexture().

## Variable Documentation

## ◆ kHasScrollingAction

constexpr int flutter::kHasScrollingAction
| constexpr

Initial value:
=
FlutterSemanticsAction::kFlutterSemanticsActionScrollLeft |
FlutterSemanticsAction::kFlutterSemanticsActionScrollRight |
FlutterSemanticsAction::kFlutterSemanticsActionScrollUp |
FlutterSemanticsAction::kFlutterSemanticsActionScrollDown

Definition at line 16 of file accessibility_bridge.cc.