Flutter Linux Embedder
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
flutter Namespace Reference

Namespaces

 internal
 
 testing
 

Classes

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

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  AppLifecycleState {
  AppLifecycleState::kDetached,
  AppLifecycleState::kResumed,
  AppLifecycleState::kInactive,
  AppLifecycleState::kHidden,
  AppLifecycleState::kPaused
}
 
enum  PlatformProvidedMenu {
  PlatformProvidedMenu::kAbout,
  PlatformProvidedMenu::kQuit,
  PlatformProvidedMenu::kServicesSubmenu,
  PlatformProvidedMenu::kHide,
  PlatformProvidedMenu::kHideOtherApplications,
  PlatformProvidedMenu::kShowAllApplications,
  PlatformProvidedMenu::kStartSpeaking,
  PlatformProvidedMenu::kStopSpeaking,
  PlatformProvidedMenu::kToggleFullScreen,
  PlatformProvidedMenu::kMinimizeWindow,
  PlatformProvidedMenu::kZoomWindow,
  PlatformProvidedMenu::kArrangeWindowsInFront
}
 

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 (Point, SetsCoordinates)
 
 TEST (Size, SetsDimensions)
 
 TEST (Size, ClampsDimensionsPositive)
 
 TEST (Rect, SetsOriginAndSize)
 
 TEST (Rect, ReturnsLTRB)
 
 TEST (Rect, ReturnsWidthHeight)
 
 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 24 of file binary_messenger.h.

◆ BinaryReply

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

Definition at line 17 of file binary_messenger.h.

◆ EncodableList

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

Definition at line 94 of file encodable_value.h.

◆ EncodableMap

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

Definition at line 95 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 51 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 29 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 24 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 27 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 23 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 };

◆ 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 };

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, kResumed, and state.

Referenced by set_app_lifecycle_state(), and TEST().

◆ 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 }

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 }

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 }

References i.

Referenced by fl_engine_get_switches(), and TEST().

◆ TEST() [1/297]

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(
67  [&callback_called, message_value](const auto& message, 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 }

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

◆ TEST() [2/297]

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 }

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

◆ TEST() [3/297]

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/297]

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, 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(), and flutter::BasicMessageChannel< T >::SetMessageHandler().

◆ TEST() [5/297]

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/297]

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 }

References i.

◆ TEST() [7/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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/297]

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(), and flutter::EventChannel< T >::SetStreamHandler().

◆ TEST() [23/297]

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(), and flutter::EventChannel< T >::SetStreamHandler().

◆ TEST() [24/297]

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(), and flutter::EventChannel< T >::SetStreamHandler().

◆ TEST() [25/297]

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(), and flutter::EventChannel< T >::SetStreamHandler().

◆ TEST() [26/297]

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(), and flutter::EventChannel< T >::SetStreamHandler().

◆ TEST() [27/297]

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 }

References error.

◆ TEST() [28/297]

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/297]

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/297]

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 }

References GetSwitchesFromEnvironment().

◆ TEST() [31/297]

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/297]

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/297]

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/297]

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 }

References FlutterDesktopMessage::struct_size, and user_data.

◆ TEST() [35/297]

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 FlutterDesktopMessage::struct_size, and user_data.

◆ TEST() [36/297]

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 FlutterDesktopMessage::message, FlutterDesktopMessage::message_size, FlutterDesktopMessage::struct_size, and user_data.

◆ TEST() [37/297]

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 }

References CheckEncodeDecode().

◆ TEST() [38/297]

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(), and flutter::JsonMethodCodec::GetInstance().

◆ TEST() [39/297]

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(), and flutter::JsonMethodCodec::GetInstance().

◆ TEST() [40/297]

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/297]

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/297]

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(), flutter::JsonMethodCodec::GetInstance(), and result.

◆ TEST() [43/297]

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(), flutter::JsonMethodCodec::GetInstance(), and result.

◆ TEST() [44/297]

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 }

References method_call.

◆ TEST() [45/297]

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 result.

◆ TEST() [46/297]

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/297]

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/297]

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/297]

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 result.

◆ TEST() [50/297]

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 result.

◆ TEST() [51/297]

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(), result, and flutter::MethodChannel< T >::SetMethodCallHandler().

◆ TEST() [52/297]

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/297]

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/297]

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, result, and value.

◆ TEST() [55/297]

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(), result, and flutter::MethodChannel< T >::SetMethodCallHandler().

◆ TEST() [56/297]

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 }

References GetExecutableDirectory().

◆ TEST() [57/297]

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 }

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

◆ TEST() [58/297]

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/297]

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/297]

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 flutter::PluginRegistrar::messenger(), and flutter::BinaryMessenger::Send().

◆ TEST() [61/297]

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 }

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

◆ TEST() [62/297]

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/297]

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/297]

flutter::TEST ( Point  ,
SetsCoordinates   
)

Definition at line 11 of file geometry_unittests.cc.

11  {
12  Point point(-30.0, 42.0);
13  EXPECT_DOUBLE_EQ(-30.0, point.x());
14  EXPECT_DOUBLE_EQ(42.0, point.y());
15 }

References flutter::Point::x(), and flutter::Point::y().

◆ TEST() [65/297]

flutter::TEST ( Rect  ,
ReturnsLTRB   
)

Definition at line 37 of file geometry_unittests.cc.

37  {
38  Point origin(-30.0, 42.0);
39  Size size(20.0, 22.0);
40  Rect rect(origin, size);
41  EXPECT_DOUBLE_EQ(-30.0, rect.left());
42  EXPECT_DOUBLE_EQ(42.0, rect.top());
43  EXPECT_DOUBLE_EQ(-10.0, rect.right());
44  EXPECT_DOUBLE_EQ(64.0, rect.bottom());
45 }

References flutter::Rect::bottom(), flutter::Rect::left(), flutter::Rect::right(), and flutter::Rect::top().

◆ TEST() [66/297]

flutter::TEST ( Rect  ,
ReturnsWidthHeight   
)

Definition at line 47 of file geometry_unittests.cc.

47  {
48  Point origin(-30.0, 42.0);
49  Size size(20.0, 22.0);
50  Rect rect(origin, size);
51  EXPECT_DOUBLE_EQ(20.0, rect.width());
52  EXPECT_DOUBLE_EQ(22.0, rect.height());
53 }

References flutter::Rect::height(), and flutter::Rect::width().

◆ TEST() [67/297]

flutter::TEST ( Rect  ,
SetsOriginAndSize   
)

Definition at line 29 of file geometry_unittests.cc.

29  {
30  Point origin(-30.0, 42.0);
31  Size size(20.0, 22.0);
32  Rect rect(origin, size);
33  EXPECT_EQ(origin, rect.origin());
34  EXPECT_EQ(size, rect.size());
35 }

References flutter::Rect::origin(), and flutter::Rect::size().

◆ TEST() [68/297]

flutter::TEST ( Size  ,
ClampsDimensionsPositive   
)

Definition at line 23 of file geometry_unittests.cc.

23  {
24  Size size(-20.0, -42.0);
25  EXPECT_DOUBLE_EQ(0.0, size.width());
26  EXPECT_DOUBLE_EQ(0.0, size.height());
27 }

References flutter::Size::height(), and flutter::Size::width().

◆ TEST() [69/297]

flutter::TEST ( Size  ,
SetsDimensions   
)

Definition at line 17 of file geometry_unittests.cc.

17  {
18  Size size(20.0, 42.0);
19  EXPECT_DOUBLE_EQ(20.0, size.width());
20  EXPECT_DOUBLE_EQ(42.0, size.height());
21 }

References flutter::Size::height(), and flutter::Size::width().

◆ TEST() [70/297]

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() [71/297]

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() [72/297]

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() [73/297]

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() [74/297]

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(u8""), bytes);
153 }

References CheckEncodeDecode().

◆ TEST() [75/297]

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() [76/297]

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() [77/297]

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() [78/297]

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() [79/297]

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() [80/297]

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() [81/297]

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() [82/297]

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() [83/297]

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 }

References CheckEncodeDecodeWithEncodePrefix(), and value.

◆ TEST() [84/297]

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() [85/297]

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() [86/297]

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(u8"hello world"), bytes);
138 }

References CheckEncodeDecode().

◆ TEST() [87/297]

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(u8"h\u263Aw"), bytes);
143 }

References CheckEncodeDecode().

◆ TEST() [88/297]

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(u8"h\U0001F602w"), bytes);
148 }

References CheckEncodeDecode().

◆ TEST() [89/297]

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() [90/297]

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() [91/297]

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() [92/297]

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() [93/297]

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() [94/297]

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(), and flutter::StandardMethodCodec::GetInstance().

◆ TEST() [95/297]

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(), and flutter::StandardMethodCodec::GetInstance().

◆ TEST() [96/297]

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() [97/297]

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() [98/297]

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(), flutter::StandardMethodCodec::GetInstance(), and result.

◆ TEST() [99/297]

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(), flutter::StandardMethodCodec::GetInstance(), and result.

◆ TEST() [100/297]

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() [101/297]

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() [102/297]

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() [103/297]

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() [104/297]

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() [105/297]

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() [106/297]

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() [107/297]

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() [108/297]

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() [109/297]

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() [110/297]

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() [111/297]

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() [112/297]

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() [113/297]

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() [114/297]

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() [115/297]

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() [116/297]

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() [117/297]

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() [118/297]

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() [119/297]

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() [120/297]

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() [121/297]

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() [122/297]

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() [123/297]

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() [124/297]

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() [125/297]

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() [126/297]

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() [127/297]

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() [128/297]

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() [129/297]

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() [130/297]

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() [131/297]

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() [132/297]

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() [133/297]

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() [134/297]

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() [135/297]

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() [136/297]

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() [137/297]

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() [138/297]

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() [139/297]

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() [140/297]

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() [141/297]

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() [142/297]

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() [143/297]

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() [144/297]

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() [145/297]

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() [146/297]

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() [147/297]

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() [148/297]

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() [149/297]

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() [150/297]

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() [151/297]

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() [152/297]

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() [153/297]

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() [154/297]

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() [155/297]

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() [156/297]

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() [157/297]

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() [158/297]

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() [159/297]

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() [160/297]

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() [161/297]

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() [162/297]

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() [163/297]

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() [164/297]

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() [165/297]

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() [166/297]

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() [167/297]

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() [168/297]

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() [169/297]

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() [170/297]

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() [171/297]

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() [172/297]

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() [173/297]

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() [174/297]

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() [175/297]

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() [176/297]

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() [177/297]

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() [178/297]

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() [179/297]

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() [180/297]

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() [181/297]

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() [182/297]

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() [183/297]

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() [184/297]

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() [185/297]

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() [186/297]

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() [187/297]

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() [188/297]

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() [189/297]

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() [190/297]

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() [191/297]

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() [192/297]

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() [193/297]

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() [194/297]

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() [195/297]

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() [196/297]

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() [197/297]

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() [198/297]

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() [199/297]

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() [200/297]

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() [201/297]

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() [202/297]

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() [203/297]

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() [204/297]

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() [205/297]

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() [206/297]

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() [207/297]

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() [208/297]

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() [209/297]

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() [210/297]

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() [211/297]

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() [212/297]

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() [213/297]

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() [214/297]

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() [215/297]

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() [216/297]

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() [217/297]

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() [218/297]

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() [219/297]

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() [220/297]

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() [221/297]

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() [222/297]

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() [223/297]

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() [224/297]

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() [225/297]

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() [226/297]

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() [227/297]

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() [228/297]

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() [229/297]

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() [230/297]

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() [231/297]

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() [232/297]

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() [233/297]

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() [234/297]

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() [235/297]

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() [236/297]

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() [237/297]

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() [238/297]

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() [239/297]

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() [240/297]

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() [241/297]

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() [242/297]

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() [243/297]

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() [244/297]

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() [245/297]

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() [246/297]

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() [247/297]

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() [248/297]

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() [249/297]

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() [250/297]

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() [251/297]

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() [252/297]

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() [253/297]

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() [254/297]

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() [255/297]

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() [256/297]

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() [257/297]

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() [258/297]

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() [259/297]

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() [260/297]

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() [261/297]

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() [262/297]

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() [263/297]

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() [264/297]

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() [265/297]

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() [266/297]

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() [267/297]

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() [268/297]

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() [269/297]

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() [270/297]

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() [271/297]

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() [272/297]

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() [273/297]

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() [274/297]

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() [275/297]

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() [276/297]

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() [277/297]

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() [278/297]

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() [279/297]

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() [280/297]

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() [281/297]

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() [282/297]

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() [283/297]

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() [284/297]

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() [285/297]

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() [286/297]

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() [287/297]

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() [288/297]

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() [289/297]

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() [290/297]

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() [291/297]

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() [292/297]

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() [293/297]

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() [294/297]

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() [295/297]

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() [296/297]

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 }

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

◆ TEST() [297/297]

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.

flutter::AppLifecycleState::kHidden
@ kHidden
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
flutter::PlatformProvidedMenu::kServicesSubmenu
@ kServicesSubmenu
flutter::PlatformProvidedMenu::kStopSpeaking
@ kStopSpeaking
i
int i
Definition: fl_socket_accessible.cc:18
user_data
FlKeyEvent uint64_t FlKeyResponderAsyncCallback gpointer user_data
Definition: fl_key_channel_responder.cc:121
flutter::PlatformProvidedMenu::kMinimizeWindow
@ kMinimizeWindow
height
G_BEGIN_DECLS int height
Definition: fl_backing_store_provider.h:37
flutter::GetExecutableDirectory
std::filesystem::path GetExecutableDirectory()
Definition: path_utils.cc:16
flutter::PlatformProvidedMenu::kToggleFullScreen
@ kToggleFullScreen
state
AtkStateType state
Definition: fl_accessible_node.cc:10
FlutterDesktopMessage::message_size
size_t message_size
Definition: flutter_messenger.h:39
flutter::AppLifecycleState::kInactive
@ kInactive
flutter::PlatformProvidedMenu::kStartSpeaking
@ kStartSpeaking
method_call
G_BEGIN_DECLS G_MODULE_EXPORT FlMethodCall * method_call
Definition: fl_method_channel.h:120
flutter::BinaryReply
std::function< void(const uint8_t *reply, size_t reply_size)> BinaryReply
Definition: binary_messenger.h:17
flutter::GetSwitchesFromEnvironment
std::vector< std::string > GetSwitchesFromEnvironment()
Definition: engine_switches.cc:14
flutter::PlatformProvidedMenu::kHideOtherApplications
@ kHideOtherApplications
flutter::PlatformProvidedMenu::kArrangeWindowsInFront
@ kArrangeWindowsInFront
result
GAsyncResult * result
Definition: fl_text_input_plugin.cc:106
flutter::StandardMessageCodec::GetInstance
static const StandardMessageCodec & GetInstance(const StandardCodecSerializer *serializer=nullptr)
Definition: standard_codec.cc:293
flutter::PlatformProvidedMenu::kAbout
@ kAbout
FlutterDesktopMessengerRef
struct FlutterDesktopMessenger * FlutterDesktopMessengerRef
Definition: flutter_messenger.h:19
flutter::EncodableList
std::vector< EncodableValue > EncodableList
Definition: encodable_value.h:94
flutter::PlatformProvidedMenu::kShowAllApplications
@ kShowAllApplications
error
const uint8_t uint32_t uint32_t GError ** error
Definition: fl_pixel_buffer_texture_test.cc:40
FlutterDesktopMessage
Definition: flutter_messenger.h:31
flutter::AppLifecycleState::kResumed
@ kResumed
flutter::AppLifecycleState::kDetached
@ kDetached
flutter::BinaryMessageHandler
std::function< void(const uint8_t *message, size_t message_size, BinaryReply reply)> BinaryMessageHandler
Definition: binary_messenger.h:24
buffer
static const uint8_t buffer[]
Definition: fl_pixel_buffer_texture_test.cc:44
flutter::EncodableMap
std::map< EncodableValue, EncodableValue > EncodableMap
Definition: encodable_value.h:95
flutter::PlatformProvidedMenu::kQuit
@ kQuit
FlutterDesktopMessage::message
const uint8_t * message
Definition: flutter_messenger.h:37
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
texture_id
int64_t texture_id
Definition: texture_registrar_unittests.cc:24
width
const uint8_t uint32_t * width
Definition: fl_pixel_buffer_texture_test.cc:38
FlutterDesktopMessage::struct_size
size_t struct_size
Definition: flutter_messenger.h:33
FlutterDesktopPluginRegistrarRef
struct FlutterDesktopPluginRegistrar * FlutterDesktopPluginRegistrarRef
Definition: flutter_plugin_registrar.h:20
value
uint8_t value
Definition: fl_standard_message_codec.cc:36
length
size_t length
Definition: fl_standard_message_codec_test.cc:1113
flutter::PlatformProvidedMenu::kZoomWindow
@ kZoomWindow
flutter::PlatformProvidedMenu::kHide
@ kHide
flutter::AppLifecycleState::kPaused
@ kPaused