Update to latest libclipboard 1.0.efaa094.

clipboard.mod/clipboard.bmx

@@ -25,11 +25,15 @@ bbdoc: Cross-platform clipboards.
 End Rem
 Module BRL.Clipboard
 
-ModuleInfo "Version: 1.00"
+ModuleInfo "Version: 1.01"
 ModuleInfo "License: MIT"
-ModuleInfo "Copyright: libclipboard - Copyright (C) 2016 Jeremy Tan."
+ModuleInfo "Copyright: libclipboard - Copyright (C) 2016-2019 Jeremy Tan."
 ModuleInfo "Copyright: Wrapper - 2018-2019 Bruce A Henderson"
 
+ModuleInfo "History: 1.01"
+ModuleInfo "History: Updated to latest libclipboard 1.0.efaa094"
+ModuleInfo "History: 1.00 Initial Release"
+
 ?win32
 ModuleInfo "CC_OPTS: -DLIBCLIPBOARD_BUILD_WIN32"
 ?linux
@@ -38,6 +42,11 @@ ModuleInfo "CC_OPTS: -DLIBCLIPBOARD_BUILD_X11"
 ModuleInfo "CC_OPTS: -DLIBCLIPBOARD_BUILD_COCOA"
 ?
 
+'
+' build notes :
+' clipboard_cocoa.c renamed to clipboard_cocoa.m
+'
+
 Import "common.bmx"
 
 Rem
@@ -240,4 +249,4 @@ returns: #True if the clipboard was set (#false on error).
 End Rem
 Function ClipboardSetTextEx:Int(clipboard:TClipboard, src:String, clipboardMode:Int = LCB_CLIPBOARD)
 	Return clipboard.SetTextEx(src, clipboardMode)
-End Function
+End Function

clipboard.mod/common.bmx

@@ -48,4 +48,9 @@ Const LCB_CLIPBOARD:Int = 0
 Rem
 bbdoc: The (global) mouse selection clipboard.
 End Rem
-Const LCB_SELECTION:Int = 1
+Const LCB_PRIMARY:Int = 1
+
+Rem
+bbdoc: The largely unused (global) secondary selection clipboard.
+End Rem
+Const LCB_SECONDARY:Int = 2

clipboard.mod/libclipboard/CMakeLists.txt

@@ -6,6 +6,7 @@ project(libclipboard)
 # Defines and options
 set(LIBCLIPBOARD_VERSION_MAJOR 1 CACHE STRING "libclipboard major version number")
 set(LIBCLIPBOARD_VERSION_MINOR 0 CACHE STRING "libclipboard minor version number")
+set(LIBCLIPBOARD_VERSION "${LIBCLIPBOARD_VERSION_MAJOR}.${LIBCLIPBOARD_VERSION_MINOR}" CACHE STRING "libclipboard version number")
 
 option(LIBCLIPBOARD_FORCE_WIN32 "Force building the Win32 backend (default:off)" OFF)
 option(LIBCLIPBOARD_FORCE_X11 "Force building the X11 backend (default:off)" OFF)

clipboard.mod/libclipboard/include/libclipboard.h

@@ -92,7 +92,11 @@ typedef enum clipboard_mode {
     /** The primary (global) clipboard **/
     LCB_CLIPBOARD = 0,
     /** The (global) mouse selection clipboard **/
-    LCB_SELECTION,
+    LCB_PRIMARY,
+    /** The (global) mouse selection clipboard; for backwards compatibility **/
+    LCB_SELECTION = LCB_PRIMARY,
+    /** The largely unused (global) secondary selection clipboard **/
+    LCB_SECONDARY,
     /** Sentinel value for end of clipboard modes **/
     LCB_MODE_END
 } clipboard_mode;

clipboard.mod/libclipboard/src/clipboard_x11.c

@@ -28,6 +28,8 @@
 #  undef gettimeofday
 #endif
 
+#define VALID_MODE(x) ((x) >= LCB_CLIPBOARD && (x) < LCB_MODE_END)
+
 /**
  *  Enumeration of standard X11 atom identifiers
  */
@@ -215,7 +217,7 @@ static void x11_retrieve_selection(clipboard_c *cb, xcb_selection_notify_event_t
     xcb_atom_t actual_type;
     uint8_t actual_format;
 
-    if (e->property != XCB_ATOM_PRIMARY && e->property != cb->std_atoms[X_ATOM_CLIPBOARD].atom) {
+    if (e->property != XCB_ATOM_PRIMARY && e->property != XCB_ATOM_SECONDARY && e->property != cb->std_atoms[X_ATOM_CLIPBOARD].atom) {
         fprintf(stderr, "x11_retrieve_selection: [Warn] Unknown selection property returned: %d\n", e->property);
         return;
     }
@@ -468,7 +470,8 @@ LCB_API clipboard_c *LCB_CC clipboard_new(clipboard_opts *cb_opts) {
     }
 
     cb->selections[LCB_CLIPBOARD].xmode = cb->std_atoms[X_ATOM_CLIPBOARD].atom;
-    cb->selections[LCB_SELECTION].xmode = XCB_ATOM_PRIMARY;
+    cb->selections[LCB_PRIMARY].xmode   = XCB_ATOM_PRIMARY;
+    cb->selections[LCB_SECONDARY].xmode = XCB_ATOM_SECONDARY;
 
     /* Structure notify mask to get DestroyNotify messages */
     /* Property change mask for PropertyChange messages */
@@ -544,9 +547,12 @@ LCB_API void LCB_CC clipboard_clear(clipboard_c *cb, clipboard_mode mode) {
         case LCB_CLIPBOARD:
             sel = cb->std_atoms[X_ATOM_CLIPBOARD].atom;
             break;
-        case LCB_SELECTION:
+        case LCB_PRIMARY:
             sel = XCB_ATOM_PRIMARY;
             break;
+        case LCB_SECONDARY:
+            sel = XCB_ATOM_SECONDARY;
+            break;
         default:
             return;
     }
@@ -558,7 +564,7 @@ LCB_API void LCB_CC clipboard_clear(clipboard_c *cb, clipboard_mode mode) {
 LCB_API bool LCB_CC clipboard_has_ownership(clipboard_c *cb, clipboard_mode mode) {
     bool ret = false;
 
-    if (mode != LCB_CLIPBOARD && mode != LCB_SELECTION) {
+    if (!VALID_MODE(mode)) {
         return false;
     }
 
@@ -594,7 +600,7 @@ static void retrieve_text_selection(clipboard_c *cb, selection_c *sel, char **re
 LCB_API char LCB_CC *clipboard_text_ex(clipboard_c *cb, int *length, clipboard_mode mode) {
     char *ret = NULL;
 
-    if (cb == NULL || (mode != LCB_CLIPBOARD && mode != LCB_SELECTION)) {
+    if (cb == NULL || !VALID_MODE(mode)) {
         return NULL;
     }
 
@@ -653,7 +659,7 @@ LCB_API char LCB_CC *clipboard_text_ex(clipboard_c *cb, int *length, clipboard_m
 LCB_API bool LCB_CC clipboard_set_text_ex(clipboard_c *cb, const char *src, int length, clipboard_mode mode) {
     bool ret = false;
 
-    if (cb == NULL || src == NULL || length == 0 || (mode != LCB_CLIPBOARD && mode != LCB_SELECTION)) {
+    if (cb == NULL || src == NULL || length == 0 || !VALID_MODE(mode)) {
         return false;
     }
 

clipboard.mod/libclipboard/test/CMakeLists.txt

@@ -16,6 +16,10 @@ add_executable (run-smoke1 smoke_test1.c)
 # Link it to gtest
 target_link_libraries(run-tests LINK_PRIVATE gtest gtest_main)
 
+if (BUILD_SHARED_LIBS)
+    target_compile_definitions(run-tests PRIVATE -DGTEST_LINKED_AS_SHARED_LIBRARY)
+endif()
+
 # Link it with libclipboard
 target_link_libraries (run-tests LINK_PUBLIC clipboard)
 target_link_libraries (run-smoke1 LINK_PUBLIC clipboard)

clipboard.mod/libclipboard/test/test_basics.cpp

@@ -2,20 +2,35 @@
  *  \file test_basics.cpp
  *  \brief Basic unit tests
  *
- *  \copyright Copyright (C) 2016 Jeremy Tan.
+ *  \copyright Copyright (C) 2016-2019 Jeremy Tan.
  *             This file is released under the MIT license.
  *             See LICENSE for details.
  */
 #include <gtest/gtest.h>
 #include <libclipboard.h>
-#include <vector>
 
 #include "libclipboard-test-private.h"
 
 class BasicsTest : public ::testing::Test {
 };
 
-TEST_F(BasicsTest, TestInstantiation) {
+TEST_F(BasicsTest, TestBackwardsCompat) {
+    EXPECT_EQ(LCB_SELECTION, LCB_PRIMARY);
+    EXPECT_NE(LCB_CLIPBOARD, LCB_PRIMARY);
+    EXPECT_NE(LCB_PRIMARY, LCB_SECONDARY);
+}
+
+class WithMode : public ::testing::TestWithParam<clipboard_mode> {
+protected:
+    void SetUp() override {
+        mMode = GetParam();
+    }
+
+    clipboard_mode mMode;
+};
+
+
+TEST_P(WithMode, TestInstantiation) {
     clipboard_c *ret = clipboard_new(NULL);
     ASSERT_TRUE(ret != NULL);
     clipboard_free(ret);
@@ -28,7 +43,7 @@ TEST_F(BasicsTest, TestInstantiation) {
 #endif
 }
 
-TEST_F(BasicsTest, TestMultipleInstantiation) {
+TEST_P(WithMode, TestMultipleInstantiation) {
     clipboard_c *cb1 = clipboard_new(NULL);
     clipboard_c *cb2 = clipboard_new(NULL);
 
@@ -39,110 +54,104 @@ TEST_F(BasicsTest, TestMultipleInstantiation) {
     clipboard_free(cb1);
 }
 
-TEST_F(BasicsTest, TestClipboardFreeWithNull) {
+TEST_P(WithMode, TestClipboardFreeWithNull) {
     /* Just make sure it doesn't segfault */
     clipboard_free(NULL);
 }
 
-TEST_F(BasicsTest, TestClearingClipboard) {
+TEST_P(WithMode, TestClearingClipboard) {
     clipboard_c *cb = clipboard_new(NULL);
 
-    clipboard_set_text_ex(cb, "cleartest", -1, LCB_CLIPBOARD);
+    clipboard_set_text_ex(cb, "cleartest", -1, mMode);
     /* Line below should have no effect */
     clipboard_clear(NULL, LCB_CLIPBOARD);
 
-    char *text = clipboard_text_ex(cb, NULL, LCB_CLIPBOARD);
+    char *text = clipboard_text_ex(cb, NULL, mMode);
     ASSERT_STREQ("cleartest", text);
     free(text);
 
-    clipboard_clear(cb, LCB_CLIPBOARD);
-    TRY_RUN_NE(clipboard_text_ex(cb, NULL, LCB_CLIPBOARD), NULL, text);
+    clipboard_clear(cb, mMode);
+    TRY_RUN_NE(clipboard_text_ex(cb, NULL, mMode), NULL, text);
     ASSERT_TRUE(text == NULL);
 
     clipboard_free(cb);
 }
 
-TEST_F(BasicsTest, TestOwnership) {
+TEST_P(WithMode, TestOwnership) {
     clipboard_c *cb1 = clipboard_new(NULL);
     clipboard_c *cb2 = clipboard_new(NULL);
-    ASSERT_FALSE(clipboard_has_ownership(cb1, LCB_CLIPBOARD));
-    ASSERT_FALSE(clipboard_has_ownership(cb2, LCB_CLIPBOARD));
-    ASSERT_FALSE(clipboard_has_ownership(cb1, LCB_SELECTION));
-    ASSERT_FALSE(clipboard_has_ownership(cb2, LCB_SELECTION));
-    ASSERT_FALSE(clipboard_has_ownership(NULL, LCB_CLIPBOARD));
-    ASSERT_FALSE(clipboard_has_ownership(NULL, LCB_SELECTION));
+    ASSERT_FALSE(clipboard_has_ownership(cb1, mMode));
+    ASSERT_FALSE(clipboard_has_ownership(cb2, mMode));
+    ASSERT_FALSE(clipboard_has_ownership(NULL, mMode));
 
     /* This test is inherently subject to race conditions as any other
        application could obtain the clipboard between setting and assertion. */
-    ASSERT_TRUE(clipboard_set_text_ex(cb1, "test", -1, LCB_CLIPBOARD));
-    ASSERT_TRUE(clipboard_has_ownership(cb1, LCB_CLIPBOARD));
+    ASSERT_TRUE(clipboard_set_text_ex(cb1, "test", -1, mMode));
+    ASSERT_TRUE(clipboard_has_ownership(cb1, mMode));
 
     char *ret;
-    ASSERT_FALSE(clipboard_has_ownership(cb2, LCB_CLIPBOARD));
+    ASSERT_FALSE(clipboard_has_ownership(cb2, mMode));
     /*
        The line below is present only for synchronisation purposes.
        On X11, it may happen that cb2's set text call happens *before*
        cb1's, meaning that the ownership would still belong to cb1.
      */
-    TRY_RUN_EQ(clipboard_text_ex(cb2, NULL, LCB_CLIPBOARD), NULL, ret);
+    TRY_RUN_EQ(clipboard_text_ex(cb2, NULL, mMode), NULL, ret);
     ASSERT_TRUE(ret != NULL);
     free(ret);
-    ASSERT_TRUE(clipboard_set_text_ex(cb2, "test2", -1, LCB_CLIPBOARD));
+    ASSERT_TRUE(clipboard_set_text_ex(cb2, "test2", -1, mMode));
 
     bool has_ownership;
-    TRY_RUN_EQ(clipboard_has_ownership(cb1, LCB_CLIPBOARD), true, has_ownership);
+    TRY_RUN_EQ(clipboard_has_ownership(cb1, mMode), true, has_ownership);
     ASSERT_FALSE(has_ownership);
-    ASSERT_TRUE(clipboard_has_ownership(cb2, LCB_CLIPBOARD));
+    ASSERT_TRUE(clipboard_has_ownership(cb2, mMode));
 
     clipboard_free(cb2);
     clipboard_free(cb1);
 }
 
-TEST_F(BasicsTest, TestSetTextEdgeCases) {
-    std::vector<clipboard_mode> modes{LCB_CLIPBOARD, LCB_SELECTION};
+TEST_P(WithMode, TestSetTextEdgeCases) {
     clipboard_c *cb1 = clipboard_new(NULL);
 
-    for (const auto &m : modes) {
-        ASSERT_FALSE(clipboard_set_text_ex(NULL, NULL, 0, m));
-        ASSERT_FALSE(clipboard_set_text_ex(NULL, NULL, -1, m));
-        ASSERT_FALSE(clipboard_set_text_ex(NULL, NULL, 10, m));
-        ASSERT_FALSE(clipboard_set_text_ex(cb1, NULL, 0, m));
-        ASSERT_FALSE(clipboard_set_text_ex(cb1, NULL, -1, m));
-        ASSERT_FALSE(clipboard_set_text_ex(cb1, NULL, 10, m));
-        ASSERT_FALSE(clipboard_set_text_ex(NULL, "test", 0, m));
-        ASSERT_FALSE(clipboard_set_text_ex(NULL, "test", -1, m));
-        ASSERT_FALSE(clipboard_set_text_ex(NULL, "test", 10, m));
-        ASSERT_FALSE(clipboard_set_text_ex(cb1, "test", 0, m));
-    }
+    ASSERT_FALSE(clipboard_set_text_ex(NULL, NULL, 0, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(NULL, NULL, -1, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(NULL, NULL, 10, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(cb1, NULL, 0, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(cb1, NULL, -1, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(cb1, NULL, 10, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(NULL, "test", 0, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(NULL, "test", -1, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(NULL, "test", 10, mMode));
+    ASSERT_FALSE(clipboard_set_text_ex(cb1, "test", 0, mMode));
 
     clipboard_free(cb1);
 }
 
-TEST_F(BasicsTest, TestSetText) {
+TEST_P(WithMode, TestSetText) {
     clipboard_c *cb1 = clipboard_new(NULL);
     clipboard_c *cb2 = clipboard_new(NULL);
     char *ret1, *ret2;
 
-    ASSERT_TRUE(clipboard_set_text_ex(cb1, "test", -1, LCB_CLIPBOARD));
+    ASSERT_TRUE(clipboard_set_text_ex(cb1, "test", -1, mMode));
 
-    ret1 = clipboard_text_ex(cb1, NULL, LCB_CLIPBOARD);
-    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, LCB_CLIPBOARD), "test", ret2);
+    ret1 = clipboard_text_ex(cb1, NULL, mMode);
+    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, mMode), "test", ret2);
     ASSERT_STREQ("test", ret1);
     ASSERT_STREQ("test", ret2);
     free(ret1);
     free(ret2);
 
-    ASSERT_TRUE(clipboard_set_text_ex(cb2, "string", -1, LCB_CLIPBOARD));
-    TRY_RUN_STRNE(clipboard_text_ex(cb1, NULL, LCB_CLIPBOARD), "string", ret1);
-    ret2 = clipboard_text_ex(cb2, NULL, LCB_CLIPBOARD);
+    ASSERT_TRUE(clipboard_set_text_ex(cb2, "string", -1, mMode));
+    TRY_RUN_STRNE(clipboard_text_ex(cb1, NULL, mMode), "string", ret1);
+    ret2 = clipboard_text_ex(cb2, NULL, mMode);
     ASSERT_STREQ("string", ret1);
     ASSERT_STREQ("string", ret2);
     free(ret1);
     free(ret2);
 
-    ASSERT_TRUE(clipboard_set_text_ex(cb1, "test", 1, LCB_CLIPBOARD));
-    ret1 = clipboard_text_ex(cb1, NULL, LCB_CLIPBOARD);
-    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, LCB_CLIPBOARD), "t", ret2);
+    ASSERT_TRUE(clipboard_set_text_ex(cb1, "test", 1, mMode));
+    ret1 = clipboard_text_ex(cb1, NULL, mMode);
+    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, mMode), "t", ret2);
     ASSERT_STREQ("t", ret1);
     ASSERT_STREQ("t", ret2);
     free(ret1);
@@ -152,38 +161,36 @@ TEST_F(BasicsTest, TestSetText) {
     clipboard_free(cb1);
 }
 
-TEST_F(BasicsTest, TestGetText) {
+TEST_P(WithMode, TestGetText) {
     clipboard_c *cb1 = clipboard_new(NULL), *cb2 = clipboard_new(NULL);
     char *ret;
     int length;
 
-    ASSERT_TRUE(clipboard_text_ex(NULL, NULL, LCB_CLIPBOARD) == NULL);
-    ASSERT_TRUE(clipboard_text_ex(NULL, NULL, LCB_SELECTION) == NULL);
-    ASSERT_TRUE(clipboard_text_ex(NULL, &length, LCB_CLIPBOARD) == NULL);
-    ASSERT_TRUE(clipboard_text_ex(NULL, &length, LCB_SELECTION) == NULL);
+    ASSERT_TRUE(clipboard_text_ex(NULL, NULL, mMode) == NULL);
+    ASSERT_TRUE(clipboard_text_ex(NULL, &length, mMode) == NULL);
 
-    clipboard_set_text_ex(cb1, "test", -1, LCB_CLIPBOARD);
-    ret = clipboard_text_ex(cb1, NULL, LCB_CLIPBOARD);
+    clipboard_set_text_ex(cb1, "test", -1, mMode);
+    ret = clipboard_text_ex(cb1, NULL, mMode);
     ASSERT_STREQ("test", ret);
     free(ret);
 
-    ret = clipboard_text_ex(cb1, &length, LCB_CLIPBOARD);
+    ret = clipboard_text_ex(cb1, &length, mMode);
     ASSERT_STREQ("test", ret);
     ASSERT_EQ(static_cast<int>(strlen("test")), length);
     free(ret);
 
-    TRY_RUN_STRNE(clipboard_text_ex(cb2, &length, LCB_CLIPBOARD), "test", ret);
+    TRY_RUN_STRNE(clipboard_text_ex(cb2, &length, mMode), "test", ret);
     ASSERT_STREQ("test", ret);
     ASSERT_EQ(static_cast<int>(strlen("test")), length);
     free(ret);
 
-    clipboard_set_text_ex(cb1, "test", 2, LCB_CLIPBOARD);
-    ret = clipboard_text_ex(cb1, &length, LCB_CLIPBOARD);
+    clipboard_set_text_ex(cb1, "test", 2, mMode);
+    ret = clipboard_text_ex(cb1, &length, mMode);
     ASSERT_STREQ("te", ret);
     ASSERT_EQ(static_cast<int>(strlen("te")), length);
     free(ret);
 
-    TRY_RUN_STRNE(clipboard_text_ex(cb2, &length, LCB_CLIPBOARD), "te", ret);
+    TRY_RUN_STRNE(clipboard_text_ex(cb2, &length, mMode), "te", ret);
     ASSERT_STREQ("te", ret);
     ASSERT_EQ(static_cast<int>(strlen("te")), length);
     free(ret);
@@ -192,16 +199,16 @@ TEST_F(BasicsTest, TestGetText) {
     clipboard_free(cb2);
 }
 
-TEST_F(BasicsTest, TestUTF8InputOutput) {
+TEST_P(WithMode, TestUTF8InputOutput) {
     clipboard_c *cb1 = clipboard_new(NULL), *cb2 = clipboard_new(NULL);
     char *ret;
 
-    ASSERT_TRUE(clipboard_set_text_ex(cb1, "\xe6\x9c\xaa\xe6\x9d\xa5", -1, LCB_CLIPBOARD));
-    ret = clipboard_text_ex(cb1, NULL, LCB_CLIPBOARD);
+    ASSERT_TRUE(clipboard_set_text_ex(cb1, "\xe6\x9c\xaa\xe6\x9d\xa5", -1, mMode));
+    ret = clipboard_text_ex(cb1, NULL, mMode);
     ASSERT_STREQ("\xe6\x9c\xaa\xe6\x9d\xa5", ret);
     free(ret);
 
-    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, LCB_CLIPBOARD), "\xe6\x9c\xaa\xe6\x9d\xa5", ret);
+    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, mMode), "\xe6\x9c\xaa\xe6\x9d\xa5", ret);
     ASSERT_STREQ("\xe6\x9c\xaa\xe6\x9d\xa5", ret);
     free(ret);
 
@@ -209,25 +216,29 @@ TEST_F(BasicsTest, TestUTF8InputOutput) {
     clipboard_free(cb2);
 }
 
-TEST_F(BasicsTest, TestNewlines) {
+TEST_P(WithMode, TestNewlines) {
     clipboard_c *cb1 = clipboard_new(NULL), *cb2 = clipboard_new(NULL);
     char *ret;
 
-    ASSERT_TRUE(clipboard_set_text_ex(cb1, "a\r\n b\r\n c\r\n", -1, LCB_CLIPBOARD));
-    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, LCB_CLIPBOARD), "a\r\n b\r\n c\r\n", ret);
+    ASSERT_TRUE(clipboard_set_text_ex(cb1, "a\r\n b\r\n c\r\n", -1, mMode));
+    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, mMode), "a\r\n b\r\n c\r\n", ret);
     ASSERT_STREQ("a\r\n b\r\n c\r\n", ret);
     free(ret);
 
-    ASSERT_TRUE(clipboard_set_text_ex(cb1, "a\n b\n c\n", -1, LCB_CLIPBOARD));
-    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, LCB_CLIPBOARD), "a\n b\n c\n", ret);
+    ASSERT_TRUE(clipboard_set_text_ex(cb1, "a\n b\n c\n", -1, mMode));
+    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, mMode), "a\n b\n c\n", ret);
     ASSERT_STREQ("a\n b\n c\n", ret);
     free(ret);
 
-    ASSERT_TRUE(clipboard_set_text_ex(cb1, "a\r b\r c\r", -1, LCB_CLIPBOARD));
-    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, LCB_CLIPBOARD), "a\r b\r c\r", ret);
+    ASSERT_TRUE(clipboard_set_text_ex(cb1, "a\r b\r c\r", -1, mMode));
+    TRY_RUN_STRNE(clipboard_text_ex(cb2, NULL, mMode), "a\r b\r c\r", ret);
     ASSERT_STREQ("a\r b\r c\r", ret);
     free(ret);
 
     clipboard_free(cb1);
     clipboard_free(cb2);
 }
+
+INSTANTIATE_TEST_CASE_P(ClipboardBasicsTest,
+                        WithMode,
+                        ::testing::Range(LCB_CLIPBOARD, LCB_MODE_END, 1));