Compare commits
No commits in common. "master" and "master" have entirely different histories.
|
@ -347,7 +347,7 @@ Required by default:
|
|||
* openjpeg2
|
||||
* gstreamer (Ensure all codecs you want are installed.)
|
||||
* zlib
|
||||
* lua (lua 5.1, luajit or lua 5.2 support optional)
|
||||
* luajit (lua 5.1 or 5.2 support optional)
|
||||
* libtiff
|
||||
* openssl
|
||||
* curl
|
||||
|
|
|
@ -337,7 +337,7 @@ color_tree {
|
|||
"/fg/normal/text-preedit";
|
||||
"/fg/normal/text-info";
|
||||
"/fg/normal/text-type";
|
||||
"/fg/normal/fileselector/pathsep";
|
||||
"/fg/nmormal/fileselector/pathsep";
|
||||
"/fg/selected/button/bar";
|
||||
"/fg/normal/button-anchor";
|
||||
"/fg/selected/thumb/bar";
|
||||
|
@ -1294,7 +1294,7 @@ color_classes {
|
|||
// color_class { name: "/fg/disabled/flipselector/up";
|
||||
// color: 96 96 96 255; }
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// color_class { name: "/fg/normal/fileselector/pathsep";
|
||||
// color_class { name: "/fg/nmormal/fileselector/pathsep";
|
||||
// color: 51 153 255 255; }
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// color_class { name: "/bg/normal/button";
|
||||
|
|
|
@ -1,13 +1,3 @@
|
|||
// Define this to enable a demo title blur
|
||||
//#define BLUR_TITLE 1
|
||||
// Define this to enable a demo blue behind everythnig - conflicts with title
|
||||
//#define BLUR_BEHIND 1
|
||||
|
||||
// Some values used if blur is enabled
|
||||
#define BLUR_FORCE_ALPHA 160
|
||||
#define BLUR_TITLE_AMOUNT "32"
|
||||
#define BLUR_BEHIND_AMOUNT "32"
|
||||
|
||||
group { name: "e/widgets/border/volume";
|
||||
images.image: "shadow_circle_vert.png" COMP;
|
||||
parts {
|
||||
|
@ -174,15 +164,6 @@ group { name: "e/widgets/border/default/border";
|
|||
}
|
||||
}
|
||||
WIN_SHAD("shadow_base", "shadow_clip", "win_shad_flat.png", 21, 21, 14, 28, 0.5)
|
||||
#ifdef BLUR_BEHIND
|
||||
snapshot { name: "title-blur"; mouse_events: 0;
|
||||
description { state: "default" 0.0;
|
||||
rel1.to: "top";
|
||||
rel2.to: "bottom";
|
||||
filter.code: "padding_set { 0 } blur { "BLUR_BEHIND_AMOUNT", color = '#ffff' }";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
part { name: "client_clip"; type: RECT; mouse_events: 0;
|
||||
description { state: "default" 0.0;
|
||||
rel1.to_y: "e.swallow.client";
|
||||
|
@ -212,23 +193,12 @@ group { name: "e/widgets/border/default/border";
|
|||
rel2.offset: -1 -1;
|
||||
}
|
||||
}
|
||||
#ifdef BLUR_TITLE
|
||||
snapshot { name: "title-blur"; mouse_events: 0;
|
||||
description { state: "default" 0.0;
|
||||
rel.to: "top";
|
||||
filter.code: "padding_set { 0 } blur { "BLUR_TITLE_AMOUNT", color = '#ffff' }";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
part { name: "top"; type: RECT; mouse_events: 0;
|
||||
scale: 1;
|
||||
description { state: "default" 0.0;
|
||||
rel2.to_y: "e.text.title";
|
||||
rel2.offset: -1 2;
|
||||
color_class: "/bg/normal/titlebar";
|
||||
#if defined(BLUR_TITLE) || defined(BLUR_BEHIND)
|
||||
color: 255 255 255 BLUR_FORCE_ALPHA;
|
||||
#endif
|
||||
offscale;
|
||||
}
|
||||
description { state: "focused" 0.0;
|
||||
|
@ -524,9 +494,6 @@ group { name: "e/widgets/border/default/border";
|
|||
description { state: "default" 0.0;
|
||||
color_class: "/bg/normal/border";
|
||||
rel.to: "bottom";
|
||||
#if defined(BLUR_BEHIND)
|
||||
color: 255 255 255 BLUR_FORCE_ALPHA;
|
||||
#endif
|
||||
}
|
||||
description { state: "focused" 0.0;
|
||||
inherit: "default" 0.0;
|
||||
|
|
|
@ -263,7 +263,7 @@ group { "efl/border"; data.item: "version" "123";
|
|||
rel2.to_x: "event.minimize";
|
||||
rel2.to_y: "shadow_base";
|
||||
align: 0.5 0.0;
|
||||
color_class: "/fg/normal/titlebar";
|
||||
color_class: "/fg/noemal/titlebar";
|
||||
min: 0 16;
|
||||
text { font: FNBD; size: 10;
|
||||
text_class: "title_bar";
|
||||
|
@ -330,7 +330,7 @@ group { "efl/border"; data.item: "version" "123";
|
|||
rel.to: "event.close";
|
||||
min: 15 15; max: 15 15;
|
||||
fixed: 1 1;
|
||||
color_class: "/fg/normal/titlebar/close";
|
||||
color_class: "/fg/noemal/titlebar/close";
|
||||
}
|
||||
desc { "selected";
|
||||
inherit: "default";
|
||||
|
@ -345,7 +345,7 @@ group { "efl/border"; data.item: "version" "123";
|
|||
rel.to: "event.maximize";
|
||||
min: 15 15; max: 15 15;
|
||||
fixed: 1 1;
|
||||
color_class: "/fg/normal/titlebar/maximize";
|
||||
color_class: "/fg/noemal/titlebar/maximize";
|
||||
}
|
||||
desc { "selected";
|
||||
inherit: "default";
|
||||
|
|
|
@ -6,7 +6,7 @@ group { name: "elm/entry/path/separator/default";
|
|||
image.normal: "i-arrow-r";
|
||||
FIXED_SIZE(15, 15)
|
||||
aspect: 1.0 1.0;
|
||||
color_class: "/fg/normal/fileselector/pathsep";
|
||||
color_class: "/fg/nmormal/fileselector/pathsep";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,9 +1,3 @@
|
|||
// Define this to enable blur background to winlist
|
||||
//#define BLUR_WINLIST 1
|
||||
|
||||
// Some values used if blur is enabled
|
||||
#define BLUR_WINLIST_AMOUNT "48"
|
||||
|
||||
group { name: "e/widgets/winlist/main";
|
||||
parts {
|
||||
part { name: "base"; type: RECT; mouse_events: 0;
|
||||
|
@ -276,27 +270,27 @@ group { name: "e/widgets/winlist/large/bg";
|
|||
color: 255 255 255 255; // no cc
|
||||
}
|
||||
}
|
||||
#ifdef BLUR_WINLIST
|
||||
/*
|
||||
snapshot { "bg_blur";
|
||||
clip_to: "bg_clip";
|
||||
description { state: "default" 0.0;
|
||||
filter.code: "padding_set { 0 } blur { state.pos * "BLUR_WINLIST_AMOUNT", color = '#ffff' }";
|
||||
filter.code: "padding_set { 0 } blur { state.pos * 50, color = '#ffff' }";
|
||||
visible: 0;
|
||||
}
|
||||
desc { state: "visible" 0.0;
|
||||
inherit: "default" 0.0;
|
||||
filter.code: "padding_set { 0 } blur { (1.0 - state.pos) * "BLUR_WINLIST_AMOUNT", color = '#ffff' }";
|
||||
filter.code: "padding_set { 0 } blur { (1.0 - state.pos) * 50, color = '#ffff' }";
|
||||
visible: 1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
*/
|
||||
part { name: "bg_darken"; type: RECT;
|
||||
clip_to: "bg_clip";
|
||||
description { state: "default" 0.0;
|
||||
color_class: "/dim/normal/winlist/base";
|
||||
}
|
||||
}
|
||||
#ifdef BLUR_WINLIST
|
||||
/*
|
||||
part { name: "shadow"; mouse_events: 0;
|
||||
clip_to: "bg_clip";
|
||||
description { state: "default" 0.0;
|
||||
|
@ -304,26 +298,26 @@ group { name: "e/widgets/winlist/large/bg";
|
|||
rel2.relative: 2.0 2.0;
|
||||
image.normal: "screen_circular_shadow.png";
|
||||
fill.smooth: 0;
|
||||
color: 255 255 255 0; // no cc
|
||||
visible: 0;
|
||||
}
|
||||
description { state: "visible" 0.0;
|
||||
inherit;
|
||||
rel1.relative: 0.0 0.0;
|
||||
rel2.relative: 1.0 1.0;
|
||||
color: 255 255 255 255; // no cc
|
||||
visible: 1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
*/
|
||||
}
|
||||
programs {
|
||||
program { signal: "e,state,visible,on"; source: "e";
|
||||
action: STATE_SET "visible" 0.0;
|
||||
transition: DECELERATE 0.2 USE_DURATION_FACTOR 1 CURRENT;
|
||||
target: "bg_clip";
|
||||
#ifdef BLUR_WINLIST
|
||||
target: "bg_blur";
|
||||
target: "shadow";
|
||||
#endif
|
||||
// target: "bg_blur";
|
||||
// target: "shadow";
|
||||
after: "show2";
|
||||
}
|
||||
program { name: "show2";
|
||||
|
@ -333,10 +327,8 @@ group { name: "e/widgets/winlist/large/bg";
|
|||
action: STATE_SET "default" 0.0;
|
||||
transition: ACCELERATE 0.2 USE_DURATION_FACTOR 1 CURRENT;
|
||||
target: "bg_clip";
|
||||
#ifdef BLUR_WINLIST
|
||||
target: "bg_blur";
|
||||
target: "shadow";
|
||||
#endif
|
||||
// target: "bg_blur";
|
||||
// target: "shadow";
|
||||
after: "hide2";
|
||||
}
|
||||
program { name: "hide2";
|
||||
|
|
|
@ -330,7 +330,7 @@ option('dotnet',
|
|||
option('lua-interpreter',
|
||||
type: 'combo',
|
||||
choices: ['luajit', 'lua'],
|
||||
value: 'lua',
|
||||
value: 'luajit',
|
||||
description: 'Which Lua back-end library to use in efl'
|
||||
)
|
||||
|
||||
|
@ -388,9 +388,3 @@ option('docs',
|
|||
value: false,
|
||||
description: 'Enable building C of documentation (Requires doxygen)'
|
||||
)
|
||||
|
||||
option('embedded-libunibreak',
|
||||
type : 'boolean',
|
||||
value : true,
|
||||
description : 'Use the embedded in-tree libunibreak instead of the system libunibreak.'
|
||||
)
|
||||
|
|
|
@ -68,7 +68,7 @@ do
|
|||
if [ $? -ne 0 ]; then
|
||||
echo "Failed compiling eet file."
|
||||
echo "Press 'Return' to reopen the editor, or ^C to abort."
|
||||
read _dummy
|
||||
read
|
||||
else
|
||||
DONE=1
|
||||
fi
|
||||
|
|
|
@ -487,7 +487,7 @@ char * get_fit_status(Eo * textblock)
|
|||
void
|
||||
test_textblock_fit(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
||||
{
|
||||
app = calloc(1, sizeof(APP));
|
||||
app = calloc(sizeof(APP), 1);
|
||||
|
||||
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
|
||||
|
||||
|
@ -616,7 +616,7 @@ static void _btn_clicked_mem(void *data EINA_UNUSED, Eo *obj, void *eventInfo EI
|
|||
void
|
||||
test_text_memory(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
||||
{
|
||||
app_mem = calloc(1, sizeof(APP_MEM));
|
||||
app_mem = calloc(sizeof(APP_MEM), 1);
|
||||
|
||||
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
|
||||
|
||||
|
|
|
@ -4,10 +4,6 @@
|
|||
|
||||
#include "common.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
# include <evil_private.h> /* setenv */
|
||||
#endif
|
||||
|
||||
Eina_Bool
|
||||
ex_is_original_app(void)
|
||||
{
|
||||
|
|
|
@ -23,11 +23,6 @@
|
|||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
# include <evil_private.h> /* setenv */
|
||||
# undef HAVE_DLSYM
|
||||
#endif
|
||||
|
||||
#include <Eina.h>
|
||||
#include <Eo.h>
|
||||
#include <Evas.h>
|
||||
|
|
|
@ -16,11 +16,6 @@
|
|||
# include <sys/sysinfo.h>
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
# include <evil_private.h> /* setenv */
|
||||
# undef HAVE_DLSYM
|
||||
#endif
|
||||
|
||||
#include <Eina.h>
|
||||
#include <Eo.h>
|
||||
#include <Evas.h>
|
||||
|
|
|
@ -43,7 +43,7 @@ ecore_drm2_plane_assign(Ecore_Drm2_Output *output, Ecore_Drm2_Fb *fb, int x, int
|
|||
{
|
||||
Eina_List *l;
|
||||
Ecore_Drm2_Plane *plane;
|
||||
Ecore_Drm2_Plane_State *pstate, *pstate_chosen = NULL;
|
||||
Ecore_Drm2_Plane_State *pstate;
|
||||
|
||||
if (!_ecore_drm2_use_atomic) return NULL;
|
||||
|
||||
|
@ -68,12 +68,12 @@ ecore_drm2_plane_assign(Ecore_Drm2_Output *output, Ecore_Drm2_Fb *fb, int x, int
|
|||
continue;
|
||||
|
||||
/* if we reach here, this FB can go on the cursor plane */
|
||||
pstate_chosen = pstate;
|
||||
goto out;
|
||||
}
|
||||
else if (pstate->type.value == DRM_PLANE_TYPE_OVERLAY)
|
||||
{
|
||||
/* there are no size checks for an overlay plane */
|
||||
pstate_chosen = pstate;
|
||||
goto out;
|
||||
}
|
||||
else if (pstate->type.value == DRM_PLANE_TYPE_PRIMARY)
|
||||
{
|
||||
|
@ -82,15 +82,10 @@ ecore_drm2_plane_assign(Ecore_Drm2_Output *output, Ecore_Drm2_Fb *fb, int x, int
|
|||
continue;
|
||||
|
||||
/* if we reach here, this FB can go on the primary plane */
|
||||
pstate_chosen = pstate;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
if (pstate_chosen)
|
||||
{
|
||||
pstate = pstate_chosen;
|
||||
goto out;
|
||||
}
|
||||
return NULL;
|
||||
|
||||
out:
|
||||
|
|
|
@ -22,6 +22,15 @@ static Eina_Module *_ecore_evas_vnc = NULL;
|
|||
# define ECORE_EVAS_ENGINE_NAME "module.so"
|
||||
#endif
|
||||
|
||||
static inline Eina_Bool
|
||||
_file_exists(const char *file)
|
||||
{
|
||||
if (!file) return EINA_FALSE;
|
||||
|
||||
if (access(file, F_OK) == -1) return EINA_FALSE;
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
|
||||
static Eina_Module *
|
||||
_ecore_evas_vnc_server_module_try_load(const char *prefix,
|
||||
|
@ -210,7 +219,7 @@ _ecore_evas_available_engines_get(void)
|
|||
eina_strbuf_append_printf(buf, "%s/%s/" ECORE_EVAS_ENGINE_NAME,
|
||||
info->path, MODULE_ARCH);
|
||||
|
||||
if (eina_file_access(eina_strbuf_string_get(buf), EINA_FILE_ACCESS_MODE_EXIST))
|
||||
if (_file_exists(eina_strbuf_string_get(buf)))
|
||||
{
|
||||
const char *name;
|
||||
|
||||
|
|
|
@ -606,19 +606,111 @@ ecore_file_dir_get(const char *file)
|
|||
EAPI Eina_Bool
|
||||
ecore_file_can_read(const char *file)
|
||||
{
|
||||
return eina_file_access(file, EINA_FILE_ACCESS_MODE_READ);
|
||||
if (!file) return EINA_FALSE;
|
||||
if (!access(file, R_OK)) return EINA_TRUE;
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
EAPI Eina_Bool
|
||||
ecore_file_can_write(const char *file)
|
||||
{
|
||||
return eina_file_access(file, EINA_FILE_ACCESS_MODE_WRITE);
|
||||
if (!file) return EINA_FALSE;
|
||||
if (!access(file, W_OK)) return EINA_TRUE;
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
EAPI Eina_Bool
|
||||
ecore_file_can_exec(const char *file)
|
||||
{
|
||||
return eina_file_access(file, EINA_FILE_ACCESS_MODE_EXEC);
|
||||
#ifdef _WIN32
|
||||
HANDLE h;
|
||||
HANDLE fm;
|
||||
char *base;
|
||||
char *base_nt;
|
||||
LARGE_INTEGER sz;
|
||||
WORD characteristics;
|
||||
#endif
|
||||
|
||||
if (!file || !*file) return EINA_FALSE;
|
||||
|
||||
#ifdef _WIN32
|
||||
/*
|
||||
* we parse the file to check if it is a PE file (EXE or DLL)
|
||||
* and we finally check whether it's a DLL or not.
|
||||
* Reference :
|
||||
* https://docs.microsoft.com/en-us/windows/win32/debug/pe-format
|
||||
*/
|
||||
h = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL,
|
||||
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
|
||||
if (h == INVALID_HANDLE_VALUE)
|
||||
goto test_bat;
|
||||
|
||||
if (!GetFileSizeEx(h, &sz))
|
||||
goto close_h;
|
||||
|
||||
/* a PE file must have at least the DOS and NT headers */
|
||||
if (sz.QuadPart < (LONGLONG)(sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS)))
|
||||
goto close_h;
|
||||
|
||||
fm = CreateFileMapping(h, NULL, PAGE_READONLY, 0, 0, NULL);
|
||||
if (fm == NULL)
|
||||
goto close_h;
|
||||
|
||||
base = (char *)MapViewOfFile(fm, FILE_MAP_READ, 0, 0, 0);
|
||||
CloseHandle(fm);
|
||||
if (base == NULL)
|
||||
goto close_h;
|
||||
|
||||
/*
|
||||
* the PE file begins with the DOS header.
|
||||
* First magic number : the DOS header must begin with a DOS magic number,
|
||||
* that is "MZ", that is 0x5a4d, stored in a WORD.
|
||||
*/
|
||||
if (*((WORD *)base) != 0x5a4d)
|
||||
goto unmap_view;
|
||||
|
||||
/*
|
||||
* The position of the NT header is located at the offset 0x3c.
|
||||
*/
|
||||
base_nt = base + *((DWORD *)(base + 0x3c));
|
||||
/*
|
||||
* The NT header begins with the magic number "PE\0\0", that is
|
||||
* 0x00004550, stored in a DWORD.
|
||||
*/
|
||||
if (*((DWORD *)base_nt) != 0x00004550)
|
||||
goto unmap_view;
|
||||
|
||||
/*
|
||||
* to get informations about executable (EXE or DLL), we look at
|
||||
* the 'Characteristics' member of the NT header, located at the offset
|
||||
* 22 (4 for the magic number, 18 for the offset) from base_nt.
|
||||
* https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#characteristics
|
||||
*/
|
||||
characteristics = *((WORD *)(base_nt + 4 + 18));
|
||||
|
||||
UnmapViewOfFile(base);
|
||||
CloseHandle(h);
|
||||
|
||||
/*
|
||||
* 0x0002 : if set, EXE or DLL
|
||||
* 0x2000 : if set, DLL
|
||||
*/
|
||||
if ((characteristics & 0x0002) && !(characteristics & 0x2000))
|
||||
return EINA_TRUE;
|
||||
unmap_view:
|
||||
UnmapViewOfFile(base);
|
||||
close_h:
|
||||
CloseHandle(h);
|
||||
test_bat:
|
||||
/*
|
||||
* a .bat file, considered as an executable, is only a text file,
|
||||
* so we rely on the extension. Not the best but we cannot do more.
|
||||
*/
|
||||
return eina_str_has_extension(file, ".bat");
|
||||
#else
|
||||
if (!access(file, X_OK)) return EINA_TRUE;
|
||||
#endif
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
EAPI char *
|
||||
|
|
|
@ -1568,7 +1568,6 @@ eet_open(const char *file,
|
|||
{
|
||||
if (mode == EET_FILE_MODE_READ_WRITE)
|
||||
{
|
||||
/* do not use eina_file_access() here */
|
||||
ret = access(file, W_OK);
|
||||
if ((ret != 0) && (errno != ENOENT)) return NULL;
|
||||
}
|
||||
|
@ -1607,7 +1606,6 @@ open_error:
|
|||
size = 0;
|
||||
|
||||
fp = NULL;
|
||||
/* do not use eina_file_access() here */
|
||||
ret = access(file, W_OK);
|
||||
if ((ret != 0) && (errno != ENOENT)) return NULL;
|
||||
}
|
||||
|
|
|
@ -460,23 +460,23 @@ eeze_disk_removable_get(Eeze_Disk *disk)
|
|||
EAPI Eina_Bool
|
||||
eeze_disk_can_mount(void)
|
||||
{
|
||||
return eina_file_access(EEZE_MOUNT_BIN,
|
||||
EINA_FILE_ACCESS_MODE_EXEC |
|
||||
EINA_FILE_ACCESS_MODE_READ);
|
||||
if (sizeof(EEZE_MOUNT_BIN) == sizeof(""))
|
||||
return EINA_FALSE;
|
||||
return access(EEZE_MOUNT_BIN, X_OK | R_OK) == 0;
|
||||
}
|
||||
|
||||
EAPI Eina_Bool
|
||||
eeze_disk_can_unmount(void)
|
||||
{
|
||||
return eina_file_access(EEZE_UNMOUNT_BIN,
|
||||
EINA_FILE_ACCESS_MODE_EXEC |
|
||||
EINA_FILE_ACCESS_MODE_READ);
|
||||
if (sizeof(EEZE_UNMOUNT_BIN) == sizeof(""))
|
||||
return EINA_FALSE;
|
||||
return access(EEZE_UNMOUNT_BIN, X_OK | R_OK) == 0;
|
||||
}
|
||||
|
||||
EAPI Eina_Bool
|
||||
eeze_disk_can_eject(void)
|
||||
{
|
||||
return eina_file_access(EEZE_EJECT_BIN,
|
||||
EINA_FILE_ACCESS_MODE_EXEC |
|
||||
EINA_FILE_ACCESS_MODE_READ);
|
||||
if (sizeof(EEZE_EJECT_BIN) == sizeof(""))
|
||||
return EINA_FALSE;
|
||||
return access(EEZE_EJECT_BIN, X_OK | R_OK) == 0;
|
||||
}
|
||||
|
|
|
@ -56,7 +56,7 @@ static Eina_Bool
|
|||
_eeze_mount_lock_mtab(void)
|
||||
{
|
||||
// DBG("Locking mlock: %s", mnt_lock_get_linkfile(_eeze_mtab_lock));
|
||||
if (EINA_LIKELY(!eina_file_access("/etc/mtab", EINA_FILE_ACCESS_MODE_WRITE)))
|
||||
if (EINA_LIKELY(access("/etc/mtab", W_OK)))
|
||||
{
|
||||
INF("Insufficient privs for mtab lock, continuing without lock");
|
||||
return EINA_TRUE;
|
||||
|
|
|
@ -148,21 +148,6 @@ typedef enum {
|
|||
EINA_FILE_REMOVE /**< This memory is to be released and any content will be lost. Subsequent accesses will succeed but return fresh memory as if accessed for the first time. This may not succeed if the filesystem does not support it. @since 1.8 */
|
||||
} Eina_File_Populate;
|
||||
|
||||
/**
|
||||
* @typedef Eina_File_Access_Mode
|
||||
* @brief Type for enumeration of a file access mode.
|
||||
* @details This type is used with eina_file_access(). Enumerations can be
|
||||
* combined bitwise with the OR operator.
|
||||
* @since 1.28
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
EINA_FILE_ACCESS_MODE_EXIST = 0, /**< existence test: F_OK */
|
||||
EINA_FILE_ACCESS_MODE_EXEC = 1 << 0, /**< exec permission: X_OK */
|
||||
EINA_FILE_ACCESS_MODE_WRITE = 1 << 1, /**< write permission: W_OK */
|
||||
EINA_FILE_ACCESS_MODE_READ = 1 << 2, /**< read permission: R_OK */
|
||||
} Eina_File_Access_Mode;
|
||||
|
||||
/* Why do this? Well PATH_MAX may vary from when eina itself is compiled
|
||||
* to when the app using eina is compiled. Exposing the path buffer below
|
||||
* can't safely and portably vary based on how/when you compile. It should
|
||||
|
@ -845,30 +830,6 @@ EINA_API void eina_file_statgen_enable(void);
|
|||
*/
|
||||
EINA_API void eina_file_statgen_disable(void);
|
||||
|
||||
/**
|
||||
* @brief Determine the accessibility of a file or path.
|
||||
*
|
||||
* @param[in] path The path to check.
|
||||
* @param[in] mode Access permissions to be checked, or existence test.
|
||||
* @return #EINA_TRUE it @p path satisfies the tests, #EINA_FALSE otherwise.
|
||||
*
|
||||
* On Linux, this function just calls the access() function. On Windows, it
|
||||
* mimics as best as possible the behavior of access():
|
||||
* - Existence is always checked.
|
||||
* - As on Windows, a file is either read only or read/write, read permission
|
||||
* is equivalent to existence. so Write permission is equivalent to not
|
||||
* being read only.
|
||||
* - A directory is always executable, except if greater privilege is needed.
|
||||
*
|
||||
* The @p mode has the same values than F_OK, X_OK, W_OK and R_OK, and the
|
||||
* usage is the same than the access() function.
|
||||
*
|
||||
* If @p path is NULL or the epty string, this function returns #EINA_FALSE.
|
||||
*
|
||||
* @since 1.28
|
||||
*/
|
||||
EINA_API Eina_Bool eina_file_access(const char *path, Eina_File_Access_Mode mode);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -870,7 +870,11 @@ eina_file_open(const char *path, Eina_Bool shared)
|
|||
n->length = file_stat.st_size;
|
||||
n->mtime = file_stat.st_mtime;
|
||||
#ifdef _STAT_VER_LINUX
|
||||
# if (defined __USE_MISC && defined st_mtime)
|
||||
n->mtime_nsec = (unsigned long int)file_stat.st_mtim.tv_nsec;
|
||||
# else
|
||||
n->mtime_nsec = (unsigned long int)file_stat.st_mtimensec;
|
||||
# endif
|
||||
#endif
|
||||
n->inode = file_stat.st_ino;
|
||||
n->fd = fd;
|
||||
|
@ -924,7 +928,11 @@ eina_file_refresh(Eina_File *file)
|
|||
file->length = file_stat.st_size;
|
||||
file->mtime = file_stat.st_mtime;
|
||||
#ifdef _STAT_VER_LINUX
|
||||
# if (defined __USE_MISC && defined st_mtime)
|
||||
file->mtime_nsec = (unsigned long int)file_stat.st_mtim.tv_nsec;
|
||||
# else
|
||||
file->mtime_nsec = (unsigned long int)file_stat.st_mtimensec;
|
||||
# endif
|
||||
#endif
|
||||
file->inode = file_stat.st_ino;
|
||||
|
||||
|
@ -1237,9 +1245,15 @@ eina_file_statat(void *container, Eina_File_Direct_Info *info, Eina_Stat *st)
|
|||
st->mtime = buf.st_mtime;
|
||||
st->ctime = buf.st_ctime;
|
||||
#ifdef _STAT_VER_LINUX
|
||||
# if (defined __USE_MISC && defined st_mtime)
|
||||
st->atimensec = buf.st_atim.tv_nsec;
|
||||
st->mtimensec = buf.st_mtim.tv_nsec;
|
||||
st->ctimensec = buf.st_ctim.tv_nsec;
|
||||
# else
|
||||
st->atimensec = buf.st_atimensec;
|
||||
st->mtimensec = buf.st_mtimensec;
|
||||
st->ctimensec = buf.st_ctimensec;
|
||||
# endif
|
||||
#else
|
||||
st->atimensec = 0;
|
||||
st->mtimensec = 0;
|
||||
|
@ -1573,13 +1587,3 @@ eina_file_mkdtemp(const char *templatename, Eina_Tmpstr **path)
|
|||
if (path) *path = eina_tmpstr_add(tmpdirname);
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
|
||||
EINA_API Eina_Bool
|
||||
eina_file_access(const char *path, Eina_File_Access_Mode mode)
|
||||
{
|
||||
if (!path || !*path)
|
||||
return EINA_FALSE;
|
||||
|
||||
return access(path, mode) == 0;
|
||||
}
|
||||
|
|
|
@ -1286,48 +1286,3 @@ eina_file_mkdtemp(const char *templatename, Eina_Tmpstr **path)
|
|||
if (path) *path = eina_tmpstr_add(tmpdirname);
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
EINA_API Eina_Bool
|
||||
eina_file_access(const char *path, Eina_File_Access_Mode mode)
|
||||
{
|
||||
DWORD attr;
|
||||
|
||||
if (!path || !*path)
|
||||
return EINA_FALSE;
|
||||
|
||||
if ((mode != EINA_FILE_ACCESS_MODE_EXIST) &&
|
||||
((mode >> 3) != 0))
|
||||
return EINA_FALSE;
|
||||
|
||||
/*
|
||||
* Always check for existence for both files and directories
|
||||
*/
|
||||
attr = GetFileAttributes(path);
|
||||
if (attr == INVALID_FILE_ATTRIBUTES)
|
||||
return EINA_FALSE;
|
||||
|
||||
/*
|
||||
* On Windows a file or path is either read/write or read only.
|
||||
* So if it exists, it has at least read access.
|
||||
* So do something only if mode is EXEC or WRITE
|
||||
*/
|
||||
|
||||
if (mode & EINA_FILE_ACCESS_MODE_EXEC)
|
||||
{
|
||||
if (!(attr & FILE_ATTRIBUTE_DIRECTORY) &&
|
||||
!eina_str_has_extension(path, ".exe") &&
|
||||
!eina_str_has_extension(path, ".bat"))
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
if (mode & EINA_FILE_ACCESS_MODE_WRITE)
|
||||
{
|
||||
if (attr == INVALID_FILE_ATTRIBUTES)
|
||||
return EINA_FALSE;
|
||||
|
||||
if (attr & FILE_ATTRIBUTE_READONLY)
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
|
|
@ -225,7 +225,7 @@ eina_hash_add_alloc_by_hash(Eina_Hash *hash,
|
|||
|
||||
if (!hash->buckets)
|
||||
{
|
||||
hash->buckets = calloc(hash->size, sizeof(Eina_Rbtree *));
|
||||
hash->buckets = calloc(sizeof (Eina_Rbtree *), hash->size);
|
||||
if (!hash->buckets) goto on_error;
|
||||
|
||||
hash_head = NULL;
|
||||
|
|
|
@ -486,20 +486,14 @@ eina_value_pset(Eina_Value *value, const void *ptr)
|
|||
{
|
||||
if (type == EINA_VALUE_TYPE_STRINGSHARE)
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Warray-bounds"
|
||||
const char *str = *((const char * const *) ptr);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
return eina_stringshare_replace((const char **)&value->value.ptr,
|
||||
str);
|
||||
}
|
||||
else if (type == EINA_VALUE_TYPE_STRING)
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Warray-bounds"
|
||||
const char *str = *((const char * const *) ptr);
|
||||
#pragma GCC diagnostic pop
|
||||
if (value->value.ptr == str) return EINA_TRUE;
|
||||
if (!str)
|
||||
{
|
||||
|
|
|
@ -276,7 +276,7 @@ _try_argv(Eina_Prefix *pfx, const char *argv0)
|
|||
/* 1. is argv0 abs path? */
|
||||
if (!eina_file_path_relative(argv0))
|
||||
{
|
||||
if (eina_file_access(argv0, EINA_FILE_ACCESS_MODE_EXEC))
|
||||
if (access(argv0, X_OK) == 0)
|
||||
{
|
||||
INF("Executable argv0 is full path = %s", argv0);
|
||||
STRDUP_REP(pfx->exe_path, argv0);
|
||||
|
@ -296,7 +296,7 @@ _try_argv(Eina_Prefix *pfx, const char *argv0)
|
|||
eina_file_path_join(joined, len, buf2, argv0);
|
||||
if (realpath(joined, buf))
|
||||
{
|
||||
if (eina_file_access(buf, EINA_FILE_ACCESS_MODE_EXEC))
|
||||
if (access(buf, X_OK) == 0)
|
||||
{
|
||||
INF("Executable relative argv0=%s, cwd=%s, realpath=%s",
|
||||
argv0, buf2, buf);
|
||||
|
@ -340,7 +340,7 @@ _try_argv(Eina_Prefix *pfx, const char *argv0)
|
|||
strcpy(buf2 + len + 1, argv0);
|
||||
if (realpath(buf2, buf))
|
||||
{
|
||||
if (eina_file_access(buf, EINA_FILE_ACCESS_MODE_EXEC))
|
||||
if (access(buf, X_OK) == 0)
|
||||
{
|
||||
STRDUP_REP(pfx->exe_path, buf);
|
||||
INF("Path %s is executable", pfx->exe_path);
|
||||
|
|
|
@ -371,17 +371,13 @@ eina_ext_deps += [iconv]
|
|||
execinfo = cc.find_library('execinfo', required: false)
|
||||
eina_ext_deps += [execinfo]
|
||||
|
||||
eina_c_args = [package_c_args, '-DEINA_BUILD']
|
||||
if sys_windows == true
|
||||
bcrypt = cc.find_library('bcrypt', required: true)
|
||||
eina_ext_deps += [bcrypt]
|
||||
if iconv.found()
|
||||
eina_c_args += '-DWINICONV_CONST='
|
||||
endif
|
||||
endif
|
||||
|
||||
eina_lib = library('eina', eina_src,
|
||||
c_args : eina_c_args,
|
||||
c_args : [package_c_args, '-DEINA_BUILD'],
|
||||
include_directories : config_dir,
|
||||
dependencies: eina_ext_deps + [eina_deps, evil],
|
||||
install: true,
|
||||
|
|
|
@ -110,9 +110,15 @@ _eio_monitor_fallback_heavy_cb(void *data, Ecore_Thread *thread)
|
|||
est->mtime = st.st_mtime;
|
||||
est->ctime = st.st_ctime;
|
||||
#ifdef _STAT_VER_LINUX
|
||||
# if (defined __USE_MISC && defined st_mtime)
|
||||
est->atimensec = st.st_atim.tv_nsec;
|
||||
est->mtimensec = st.st_mtim.tv_nsec;
|
||||
est->ctimensec = st.st_ctim.tv_nsec;
|
||||
# else
|
||||
est->atimensec = st.st_atimensec;
|
||||
est->mtimensec = st.st_mtimensec;
|
||||
est->ctimensec = st.st_ctimensec;
|
||||
# endif
|
||||
#else
|
||||
est->atimensec = 0;
|
||||
est->mtimensec = 0;
|
||||
|
|
|
@ -128,9 +128,15 @@ _eio_file_struct_2_eina(Eina_Stat *es, _eio_stat_t *st)
|
|||
es->mtime = st->st_mtime;
|
||||
es->ctime = st->st_ctime;
|
||||
#ifdef _STAT_VER_LINUX
|
||||
# if (defined __USE_MISC && defined st_mtime)
|
||||
es->atimensec = st->st_atim.tv_nsec;
|
||||
es->mtimensec = st->st_mtim.tv_nsec;
|
||||
es->ctimensec = st->st_ctim.tv_nsec;
|
||||
# else
|
||||
es->atimensec = st->st_atimensec;
|
||||
es->mtimensec = st->st_mtimensec;
|
||||
es->ctimensec = st->st_ctimensec;
|
||||
# endif
|
||||
#else
|
||||
es->atimensec = 0;
|
||||
es->mtimensec = 0;
|
||||
|
|
|
@ -122,7 +122,7 @@ _size_cache_require(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_Grid_Data *pd)
|
|||
pd->size_cache_dirty = EINA_FALSE;
|
||||
if (pd->size_cache)
|
||||
free(pd->size_cache);
|
||||
pd->size_cache = calloc(eina_inarray_count(pd->group_cache), sizeof(int));
|
||||
pd->size_cache = calloc(sizeof(int), eina_inarray_count(pd->group_cache));
|
||||
|
||||
for (unsigned int i = 0; i < eina_inarray_count(pd->group_cache); ++i)
|
||||
{
|
||||
|
|
|
@ -3349,15 +3349,8 @@ _efl_ui_textbox_efl_ui_scrollable_scroll_hold_get(const Eo *obj EINA_UNUSED, Efl
|
|||
EOLIAN static void
|
||||
_efl_ui_textbox_efl_ui_scrollable_scroll_hold_set(Eo *obj EINA_UNUSED, Efl_Ui_Textbox_Data *sd, Eina_Bool hold)
|
||||
{
|
||||
/* Can be called by efl_ui_widget_scroll_hold_{pop, push} from another
|
||||
* widget (ex., efl_ui_slider) without _efl_ui_textbox_scrollable_set()
|
||||
* invocation with undefined sd->scroller here as the result.
|
||||
* So, check if sd->scroll is true to avoid this. */
|
||||
if(sd->scroll)
|
||||
{
|
||||
EINA_SAFETY_ON_NULL_RETURN(sd->scroller);
|
||||
efl_ui_scrollable_scroll_hold_set(sd->scroller, !!hold);
|
||||
}
|
||||
EINA_SAFETY_ON_NULL_RETURN(sd->scroller);
|
||||
efl_ui_scrollable_scroll_hold_set(sd->scroller, !!hold);
|
||||
}
|
||||
|
||||
EOLIAN static Eina_Bool
|
||||
|
@ -3370,12 +3363,8 @@ _efl_ui_textbox_efl_ui_scrollable_scroll_freeze_get(const Eo *obj EINA_UNUSED, E
|
|||
EOLIAN static void
|
||||
_efl_ui_textbox_efl_ui_scrollable_scroll_freeze_set(Eo *obj EINA_UNUSED, Efl_Ui_Textbox_Data *sd, Eina_Bool freeze)
|
||||
{
|
||||
/* The same as for hold_set. See comments above. */
|
||||
if(sd->scroll)
|
||||
{
|
||||
EINA_SAFETY_ON_NULL_RETURN(sd->scroller);
|
||||
efl_ui_scrollable_scroll_freeze_set(sd->scroller, !!freeze);
|
||||
}
|
||||
EINA_SAFETY_ON_NULL_RETURN(sd->scroller);
|
||||
efl_ui_scrollable_scroll_freeze_set(sd->scroller, !!freeze);
|
||||
}
|
||||
|
||||
EOLIAN static void
|
||||
|
|
|
@ -3563,13 +3563,13 @@ _elm_win_xwin_update(Efl_Ui_Win_Data *sd)
|
|||
|
||||
if (image)
|
||||
{
|
||||
int w = 0, h = 0, stride = 0, x, y;
|
||||
int w = 0, h = 0, stride, x, y;
|
||||
Eina_Bool unmap = EINA_FALSE;
|
||||
Eina_Rw_Slice sl = { 0 };
|
||||
Eina_Rw_Slice sl = {};
|
||||
|
||||
if (efl_isa(image, EFL_CANVAS_IMAGE_CLASS))
|
||||
{
|
||||
Eina_Rect rect = { 0 };
|
||||
Eina_Rect rect = {};
|
||||
|
||||
unmap = EINA_TRUE;
|
||||
rect.size = efl_gfx_buffer_size_get(image);
|
||||
|
|
|
@ -1044,7 +1044,7 @@ elm_quicklaunch_prepare(int argc,
|
|||
strcat(p, "../lib/");
|
||||
strcat(p, exename);
|
||||
strcat(p, LIBEXT);
|
||||
if (!eina_file_access(exe2, EINA_FILE_ACCESS_MODE_EXEC | EINA_FILE_ACCESS_MODE_READ))
|
||||
if (access(exe2, R_OK | X_OK) != 0)
|
||||
ELM_SAFE_FREE(exe2, free);
|
||||
|
||||
/* Try linking to executable first. Works with PIE files. */
|
||||
|
@ -1348,7 +1348,7 @@ elm_quicklaunch_exe_path_get(const char *exe, const char *cwd)
|
|||
EINA_LIST_FOREACH(pathlist, l, pathitr)
|
||||
{
|
||||
snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
|
||||
if (eina_file_access(buf, EINA_FILE_ACCESS_MODE_EXEC | EINA_FILE_ACCESS_MODE_READ)) return strdup(buf);
|
||||
if (!access(buf, R_OK | X_OK)) return strdup(buf);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -94,20 +94,19 @@ _eo_obj_pointer_get(const Eo_Id obj_id, const char *func_name, const char *file,
|
|||
EINA_PREFETCH(&(data->tables[0]));
|
||||
domain = (obj_id >> SHIFT_DOMAIN) & MASK_DOMAIN;
|
||||
tdata = _eo_table_data_table_get(data, domain);
|
||||
EINA_PREFETCH(&(tdata->cache.id));
|
||||
if (EINA_UNLIKELY(!tdata)) goto err;
|
||||
_eo_cache_prefetch(tdata);
|
||||
|
||||
|
||||
if (EINA_LIKELY(domain != EFL_ID_DOMAIN_SHARED))
|
||||
{
|
||||
_Eo_Object *obj;
|
||||
|
||||
obj = _eo_cache_find(tdata, obj_id);
|
||||
if (obj) return obj;
|
||||
if (obj_id == tdata->cache.id)
|
||||
return tdata->cache.object;
|
||||
|
||||
mid_table_id = (obj_id >> SHIFT_MID_TABLE_ID) & MASK_MID_TABLE_ID;
|
||||
EINA_PREFETCH(&(tdata->eo_ids_tables[mid_table_id])); //prefetch for line 119
|
||||
EINA_PREFETCH_NOCACHE(&(tdata->eo_ids_tables[mid_table_id])); //prefetch for line 119
|
||||
table_id = (obj_id >> SHIFT_TABLE_ID) & MASK_TABLE_ID;
|
||||
EINA_PREFETCH((tdata->eo_ids_tables[mid_table_id] + table_id)); //prefetch for line 121
|
||||
EINA_PREFETCH_NOCACHE((tdata->eo_ids_tables[mid_table_id] + table_id)); //prefetch for line 121
|
||||
entry_id = (obj_id >> SHIFT_ENTRY_ID) & MASK_ENTRY_ID;
|
||||
generation = obj_id & MASK_GENERATIONS;
|
||||
|
||||
|
@ -127,7 +126,8 @@ _eo_obj_pointer_get(const Eo_Id obj_id, const char *func_name, const char *file,
|
|||
if (entry->active && (entry->generation == generation))
|
||||
{
|
||||
// Cache the result of that lookup
|
||||
_eo_cache_store(tdata, obj_id, entry->ptr);
|
||||
tdata->cache.object = entry->ptr;
|
||||
tdata->cache.id = obj_id;
|
||||
return entry->ptr;
|
||||
}
|
||||
}
|
||||
|
@ -136,19 +136,17 @@ _eo_obj_pointer_get(const Eo_Id obj_id, const char *func_name, const char *file,
|
|||
}
|
||||
else
|
||||
{
|
||||
_Eo_Object *obj;
|
||||
|
||||
eina_lock_take(&(_eo_table_data_shared_data->obj_lock));
|
||||
if (obj_id == tdata->cache.id)
|
||||
// yes we return keeping the lock locked. that's why
|
||||
// you must call _eo_obj_pointer_done() wrapped
|
||||
// by EO_OBJ_DONE() to release
|
||||
obj = _eo_cache_find(tdata, obj_id);
|
||||
if (obj) return obj;
|
||||
return tdata->cache.object;
|
||||
|
||||
mid_table_id = (obj_id >> SHIFT_MID_TABLE_ID) & MASK_MID_TABLE_ID;
|
||||
EINA_PREFETCH(&(tdata->eo_ids_tables[mid_table_id]));
|
||||
EINA_PREFETCH_NOCACHE(&(tdata->eo_ids_tables[mid_table_id]));
|
||||
table_id = (obj_id >> SHIFT_TABLE_ID) & MASK_TABLE_ID;
|
||||
EINA_PREFETCH((tdata->eo_ids_tables[mid_table_id] + table_id));
|
||||
EINA_PREFETCH_NOCACHE((tdata->eo_ids_tables[mid_table_id] + table_id));
|
||||
entry_id = (obj_id >> SHIFT_ENTRY_ID) & MASK_ENTRY_ID;
|
||||
generation = obj_id & MASK_GENERATIONS;
|
||||
|
||||
|
@ -169,7 +167,8 @@ _eo_obj_pointer_get(const Eo_Id obj_id, const char *func_name, const char *file,
|
|||
if (entry->active && (entry->generation == generation))
|
||||
{
|
||||
// Cache the result of that lookup
|
||||
_eo_cache_store(tdata, obj_id, entry->ptr);
|
||||
tdata->cache.object = entry->ptr;
|
||||
tdata->cache.id = obj_id;
|
||||
// yes we return keeping the lock locked. that's why
|
||||
// you must call _eo_obj_pointer_done() wrapped
|
||||
// by EO_OBJ_DONE() to release
|
||||
|
|
|
@ -305,19 +305,13 @@ typedef struct
|
|||
typedef struct _Eo_Id_Data Eo_Id_Data;
|
||||
typedef struct _Eo_Id_Table_Data Eo_Id_Table_Data;
|
||||
|
||||
#define CACHENUM 2
|
||||
#define CACHELINE 64
|
||||
#define CACHELRU 1
|
||||
|
||||
struct _Eo_Id_Table_Data
|
||||
{
|
||||
/* Cached eoid lookups */
|
||||
#if CACHENUM > 0
|
||||
Eo_Id cache_id[CACHENUM];
|
||||
_Eo_Object *cache_object[CACHENUM];
|
||||
#endif
|
||||
struct
|
||||
{
|
||||
Eo_Id id;
|
||||
_Eo_Object *object;
|
||||
const Eo *isa_id;
|
||||
const Efl_Class *klass;
|
||||
Eina_Bool isa;
|
||||
|
@ -349,100 +343,6 @@ extern Eina_TLS _eo_table_data;
|
|||
extern Eo_Id_Data *_eo_table_data_shared;
|
||||
extern Eo_Id_Table_Data *_eo_table_data_shared_data;
|
||||
|
||||
#ifndef CACHELRU
|
||||
static inline unsigned int
|
||||
_eo_cache_slot_get(void)
|
||||
{
|
||||
# if CACHENUM > 0
|
||||
static unsigned int num = 0;
|
||||
|
||||
return (++num) % CACHENUM;
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline void
|
||||
_eo_cache_prefetch(Eo_Id_Table_Data *tdata EINA_UNUSED)
|
||||
{
|
||||
#if CACHENUM > 0
|
||||
int i;
|
||||
|
||||
for (i = 0; i < CACHENUM; i += (CACHELINE / sizeof(void *)))
|
||||
{
|
||||
EINA_PREFETCH(&(tdata->cache_id[i]));
|
||||
if ((sizeof(void *) * CACHENUM) >= CACHELINE)
|
||||
{
|
||||
EINA_PREFETCH(&(tdata->cache_object[i]));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline _Eo_Object *
|
||||
_eo_cache_find(Eo_Id_Table_Data *tdata EINA_UNUSED, Eo_Id obj_id EINA_UNUSED)
|
||||
{
|
||||
#if CACHENUM > 0
|
||||
int i;
|
||||
|
||||
for (i = 0; i < CACHENUM; i++)
|
||||
{
|
||||
if (obj_id == tdata->cache_id[i]) return tdata->cache_object[i];
|
||||
}
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline void
|
||||
_eo_cache_store(Eo_Id_Table_Data *tdata EINA_UNUSED, Eo_Id obj_id EINA_UNUSED, _Eo_Object *obj EINA_UNUSED)
|
||||
{
|
||||
#if CACHENUM > 0
|
||||
# ifdef CACHELRU
|
||||
# if CACHENUM > 1
|
||||
memmove(&tdata->cache_id[1], &tdata->cache_id[0],
|
||||
(CACHENUM - 1) * sizeof(tdata->cache_id[0]));
|
||||
memmove(&tdata->cache_object[1], &tdata->cache_object[0],
|
||||
(CACHENUM - 1) * sizeof(tdata->cache_object[0]));
|
||||
# endif
|
||||
tdata->cache_id[0] = obj_id;
|
||||
tdata->cache_object[0] = obj;
|
||||
# else
|
||||
int slot = _eo_cache_slot_get();
|
||||
tdata->cache_id[slot] = obj_id;
|
||||
tdata->cache_object[slot] = obj;
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline void
|
||||
_eo_cache_invalidate(Eo_Id_Table_Data *tdata EINA_UNUSED, Eo_Id obj_id EINA_UNUSED)
|
||||
{
|
||||
#if CACHENUM > 0
|
||||
int i;
|
||||
|
||||
for (i = 0; i < CACHENUM; i++)
|
||||
{
|
||||
if (obj_id == tdata->cache_id[i])
|
||||
{
|
||||
# ifdef CACHELRU
|
||||
if (EINA_LIKELY((CACHENUM - 1 - i) > 0))
|
||||
{
|
||||
memmove(&tdata->cache_id[i], &tdata->cache_id[i + 1],
|
||||
(CACHENUM - 1 - i) * sizeof(tdata->cache_id[0]));
|
||||
memmove(&tdata->cache_object[i], &tdata->cache_object[i + 1],
|
||||
(CACHENUM - 1 - i) * sizeof(tdata->cache_object[0]));
|
||||
}
|
||||
tdata->cache_id[CACHENUM - 1] = 0;
|
||||
tdata->cache_object[CACHENUM - 1] = NULL;
|
||||
# else
|
||||
tdata->cache_id[i] = 0;
|
||||
tdata->cache_object[i] = NULL;
|
||||
# endif
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline Eo_Id_Table_Data *
|
||||
_eo_table_data_table_new(Efl_Id_Domain domain)
|
||||
{
|
||||
|
@ -772,7 +672,11 @@ _eo_id_release(const Eo_Id obj_id)
|
|||
tdata->current_table = NULL;
|
||||
}
|
||||
// In case an object is destroyed, wipe out the cache
|
||||
_eo_cache_invalidate(tdata, obj_id);
|
||||
if (tdata->cache.id == obj_id)
|
||||
{
|
||||
tdata->cache.id = 0;
|
||||
tdata->cache.object = NULL;
|
||||
}
|
||||
if ((Eo_Id)tdata->cache.isa_id == obj_id)
|
||||
{
|
||||
tdata->cache.isa_id = NULL;
|
||||
|
@ -818,7 +722,11 @@ _eo_id_release(const Eo_Id obj_id)
|
|||
tdata->current_table = NULL;
|
||||
}
|
||||
// In case an object is destroyed, wipe out the cache
|
||||
_eo_cache_invalidate(tdata, obj_id);
|
||||
if (tdata->cache.id == obj_id)
|
||||
{
|
||||
tdata->cache.id = 0;
|
||||
tdata->cache.object = NULL;
|
||||
}
|
||||
if ((Eo_Id)tdata->cache.isa_id == obj_id)
|
||||
{
|
||||
tdata->cache.isa_id = NULL;
|
||||
|
|
|
@ -852,7 +852,7 @@ ethumb_file_set(Ethumb *e, const char *path, const char *key)
|
|||
|
||||
sanitized_path = eina_file_path_sanitize(path);
|
||||
DBG("ethumb=%p, path=%s, key=%s", e, sanitized_path ? sanitized_path : "", key ? key : "");
|
||||
if (sanitized_path && !eina_file_access(sanitized_path, EINA_FILE_ACCESS_MODE_READ))
|
||||
if (sanitized_path && access(sanitized_path, R_OK))
|
||||
{
|
||||
free(sanitized_path);
|
||||
return EINA_FALSE;
|
||||
|
|
|
@ -201,8 +201,13 @@ _timestamp_compare(Image_Timestamp *tstamp, struct stat *st)
|
|||
if (tstamp->size != st->st_size) return EINA_FALSE;
|
||||
if (tstamp->ino != st->st_ino) return EINA_FALSE;
|
||||
#ifdef _STAT_VER_LINUX
|
||||
#if (defined __USE_MISC && defined st_mtime)
|
||||
if (tstamp->mtime_nsec != (unsigned long int)st->st_mtim.tv_nsec)
|
||||
return EINA_FALSE;
|
||||
#else
|
||||
if (tstamp->mtime_nsec != (unsigned long int)st->st_mtimensec)
|
||||
return EINA_FALSE;
|
||||
#endif
|
||||
#endif
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
@ -214,7 +219,11 @@ _timestamp_build(Image_Timestamp *tstamp, struct stat *st)
|
|||
tstamp->size = st->st_size;
|
||||
tstamp->ino = st->st_ino;
|
||||
#ifdef _STAT_VER_LINUX
|
||||
#if (defined __USE_MISC && defined st_mtime)
|
||||
tstamp->mtime_nsec = (unsigned long int)st->st_mtim.tv_nsec;
|
||||
#else
|
||||
tstamp->mtime_nsec = (unsigned long int)st->st_mtimensec;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
@ -415,7 +415,11 @@ _timestamp_build(Image_Timestamp *tstamp, struct stat *st)
|
|||
tstamp->size = st->st_size;
|
||||
tstamp->ino = st->st_ino;
|
||||
#ifdef _STAT_VER_LINUX
|
||||
# if (defined __USE_MISC && defined st_mtime)
|
||||
tstamp->mtime_nsec = (unsigned long int)st->st_mtim.tv_nsec;
|
||||
# else
|
||||
tstamp->mtime_nsec = (unsigned long int)st->st_mtimensec;
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
# ifdef SCALE_USING_NEON
|
||||
# ifndef COLBLACK
|
||||
uint16x4_t temp_16x4 = { 0, 0, 0, 0 };
|
||||
uint16x4_t temp_16x4;
|
||||
uint16x4_t rv_16x4;
|
||||
uint16x4_t val1_16x4;
|
||||
uint16x4_t val3_16x4;
|
||||
|
@ -19,8 +19,8 @@
|
|||
uint16x8_t val2_val4_16x8;
|
||||
uint16x8_t x255_16x8;
|
||||
uint32x2_t res_32x2;
|
||||
uint32x2_t val1_val3_32x2 = { 0, 0 };
|
||||
uint32x2_t val2_val4_32x2 = { 0, 0 };
|
||||
uint32x2_t val1_val3_32x2;
|
||||
uint32x2_t val2_val4_32x2;
|
||||
uint8x8_t val1_val3_8x8;
|
||||
uint8x8_t val2_val4_8x8;
|
||||
|
||||
|
@ -33,7 +33,7 @@
|
|||
uint16x4_t c1_val3_16x4;
|
||||
uint16x8_t c1_16x8;
|
||||
uint16x8_t c1_val3_16x8;
|
||||
uint32x2_t c1_32x2 = { 0, 0 };
|
||||
uint32x2_t c1_32x2;
|
||||
uint8x8_t c1_8x8;
|
||||
uint8x8_t c1_val3_8x8;
|
||||
|
||||
|
@ -49,7 +49,7 @@
|
|||
uint16x8_t c1_val1_16x8;
|
||||
uint16x8_t c2_val3_16x8;
|
||||
uint16x8_t cv_rv_16x8;
|
||||
uint32x2_t c1_c2_32x2 = { 0, 0 };
|
||||
uint32x2_t c1_c2_32x2;
|
||||
uint8x8_t c1_c2_8x8;
|
||||
uint8x8_t val3_8x8;
|
||||
uint16x8_t val3_16x8;
|
||||
|
@ -247,21 +247,21 @@
|
|||
# ifndef COLBLACK
|
||||
# ifdef COLMUL
|
||||
uint16x4_t x255_16x4;
|
||||
uint16x4_t temp_16x4 = { 0, 0, 0, 0 };
|
||||
uint16x4_t temp_16x4;
|
||||
uint16x8_t cval_16x8;
|
||||
uint32x2_t res_32x2;
|
||||
uint8x8_t cval_8x8;
|
||||
uint16x4_t c1_16x4;
|
||||
uint16x4_t cval_16x4;
|
||||
uint16x4_t val1_16x4;
|
||||
uint32x2_t val1_32x2 = { 0, 0 };
|
||||
uint32x2_t val1_32x2;
|
||||
uint8x8_t val1_8x8;
|
||||
|
||||
x255_16x4 = vdup_n_u16(0xff);
|
||||
# ifdef COLSAME
|
||||
uint16x8_t c1_16x8;
|
||||
uint16x8_t val1_16x8;
|
||||
uint32x2_t c1_32x2 = { 0, 0 };
|
||||
uint32x2_t c1_32x2;
|
||||
uint8x8_t c1_8x8;
|
||||
|
||||
c1_32x2 = vset_lane_u32(c1, c1_32x2, 0);
|
||||
|
@ -277,7 +277,7 @@
|
|||
uint16x4_t cv_16x4;
|
||||
uint16x8_t c1_c2_16x8;
|
||||
uint16x8_t val1_16x8;
|
||||
uint32x2_t c1_c2_32x2 = { 0, 0 };
|
||||
uint32x2_t c1_c2_32x2;
|
||||
uint8x8_t c1_c2_8x8;
|
||||
|
||||
c1_c2_32x2 = vset_lane_u32(c1, c1_c2_32x2, 0);
|
||||
|
|
|
@ -30,7 +30,7 @@ _op_blend_mas_c_dp_neon(DATA32 *s EINA_UNUSED, DATA8 *m, DATA32 c, DATA32 *d, in
|
|||
uint16x8_t temp1_16x8;
|
||||
uint16x8_t x255_16x8;
|
||||
uint32x2_t c_32x2;
|
||||
uint32x2_t m_32x2 = { 0, 0 };
|
||||
uint32x2_t m_32x2;
|
||||
uint32x4_t a_32x4;
|
||||
uint32x4_t ad_32x4;
|
||||
uint32x4_t cond_32x4;
|
||||
|
@ -294,7 +294,7 @@ _op_blend_mas_can_dp_neon(DATA32 *s EINA_UNUSED, DATA8 *m, DATA32 c, DATA32 *d,
|
|||
uint16x8_t m1_16x8;
|
||||
uint16x8_t m_16x8;
|
||||
uint32x2_t c_32x2;
|
||||
uint32x2_t m_32x2 = { 0, 0 };
|
||||
uint32x2_t m_32x2;
|
||||
uint32x4_t d_32x4;
|
||||
uint32x4_t dc_32x4;
|
||||
uint32x4_t m_32x4;
|
||||
|
@ -695,7 +695,7 @@ _op_blend_rel_mas_c_dp_neon(DATA32 *s EINA_UNUSED, DATA8 *m, DATA32 c, DATA32 *d
|
|||
uint16x8_t temp1_16x8;
|
||||
uint16x8_t x255_16x8;
|
||||
uint32x2_t c_32x2;
|
||||
uint32x2_t m_32x2 = { 0, 0 };
|
||||
uint32x2_t m_32x2;
|
||||
uint32x4_t a_32x4;
|
||||
uint32x4_t ad_32x4;
|
||||
uint32x4_t cond_32x4;
|
||||
|
|
|
@ -13,7 +13,7 @@ _op_blend_pas_mas_dp_neon(DATA32 *s, DATA8 *m, DATA32 c EINA_UNUSED, DATA32 *d,
|
|||
uint16x8_t temp1_16x8;
|
||||
uint16x8_t x255_16x8;
|
||||
uint32_t m_32;
|
||||
uint32x2_t m_32x2 = {0, 0};
|
||||
uint32x2_t m_32x2;
|
||||
uint32x4_t a_32x4;
|
||||
uint32x4_t ad_32x4;
|
||||
uint32x4_t cond_32x4;
|
||||
|
@ -217,7 +217,7 @@ _op_blend_p_mas_dp_neon(DATA32 *s, DATA8 *m, DATA32 c EINA_UNUSED, DATA32 *d, in
|
|||
uint16x8_t temp0_16x8;
|
||||
uint16x8_t temp1_16x8;
|
||||
uint16x8_t x255_16x8;
|
||||
uint32x2_t m_32x2 = { 0, 0 };
|
||||
uint32x2_t m_32x2;
|
||||
uint32x4_t a_32x4;
|
||||
uint32x4_t ad_32x4;
|
||||
uint32x4_t cond_32x4;
|
||||
|
|
|
@ -92,18 +92,9 @@ _interpolate_linear(DATA8 *output, int *points)
|
|||
{
|
||||
if (points[j] != -1)
|
||||
{
|
||||
int val1, val2, vald, pos, len;
|
||||
|
||||
output[j] = (DATA8) points[j];
|
||||
val1 = points[last_idx];
|
||||
val2 = points[j];
|
||||
vald = val2 - val1;
|
||||
len = j - last_idx;
|
||||
for (k = last_idx + 1; k < j; k++)
|
||||
{
|
||||
pos = k - last_idx;
|
||||
output[k] = (DATA8) (val1 + ((pos * vald) / len));
|
||||
}
|
||||
output[k] = (DATA8) (points[j] + ((k - last_idx) * (points[j] - points[last_idx]) / (j - last_idx)));
|
||||
last_idx = j;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -209,30 +209,8 @@ endif
|
|||
if get_option('opengl') != 'none'
|
||||
if get_option('opengl') == 'es-egl'
|
||||
config_h.set('GL_GLES', '1')
|
||||
# Angle library does not provide .pc files
|
||||
if sys_windows
|
||||
glesv2_dep = cc.find_library(
|
||||
'GLESv2',
|
||||
has_headers: 'GLES2/gl2.h'
|
||||
)
|
||||
if glesv2_dep.found()
|
||||
gl_deps += glesv2_dep
|
||||
else
|
||||
error('GLES 2.0 library not found. Please make sure Angle library is installed, or disable OpenGL support.')
|
||||
endif
|
||||
egl_dep = cc.find_library(
|
||||
'EGL',
|
||||
has_headers: 'EGL/egl.h'
|
||||
)
|
||||
if egl_dep.found()
|
||||
gl_deps += egl_dep
|
||||
else
|
||||
error('EGL library not found. Please make sure Angle library is installed, or disable OpenGL support.')
|
||||
endif
|
||||
else
|
||||
gl_deps += dependency('glesv2')
|
||||
gl_deps += dependency('egl')
|
||||
endif
|
||||
gl_deps += dependency('glesv2')
|
||||
gl_deps += dependency('egl')
|
||||
else
|
||||
gl_deps += dependency('gl')
|
||||
endif
|
||||
|
|
|
@ -1,35 +1,32 @@
|
|||
if (get_option('embedded-libunibreak'))
|
||||
libunibreak_src = [
|
||||
'unibreakbase.h',
|
||||
'unibreakdef.h',
|
||||
'linebreak.h',
|
||||
'linebreakdef.h',
|
||||
'wordbreakdef.h',
|
||||
'wordbreak.h',
|
||||
'unibreakbase.c',
|
||||
'unibreakdef.c',
|
||||
'linebreak.c',
|
||||
'linebreakdata.c',
|
||||
'linebreakdef.c',
|
||||
'wordbreak.c',
|
||||
'graphemebreak.c',
|
||||
'graphemebreak.h',
|
||||
'graphemebreakdef.h',
|
||||
'emojidef.h',
|
||||
'emojidef.c',
|
||||
]
|
||||
|
||||
libunibreak_lib = static_library('libunibreak',
|
||||
libunibreak_src,
|
||||
include_directories : config_dir,
|
||||
install: false,
|
||||
)
|
||||
libunibreak_src = [
|
||||
'unibreakbase.h',
|
||||
'unibreakdef.h',
|
||||
'linebreak.h',
|
||||
'linebreakdef.h',
|
||||
'wordbreakdef.h',
|
||||
'wordbreak.h',
|
||||
'unibreakbase.c',
|
||||
'unibreakdef.c',
|
||||
'linebreak.c',
|
||||
'linebreakdata.c',
|
||||
'linebreakdef.c',
|
||||
'wordbreak.c',
|
||||
'graphemebreak.c',
|
||||
'graphemebreak.h',
|
||||
'graphemebreakdef.h',
|
||||
'emojidef.h',
|
||||
'emojidef.c',
|
||||
]
|
||||
|
||||
libunibreak = declare_dependency(
|
||||
include_directories: [include_directories('.')],
|
||||
link_with: libunibreak_lib,
|
||||
dependencies: [eina],
|
||||
)
|
||||
else
|
||||
libunibreak = dependency('libunibreak', version : '>=4.2')
|
||||
endif
|
||||
libunibreak_lib = static_library('libunibreak',
|
||||
libunibreak_src,
|
||||
include_directories : config_dir,
|
||||
install: false,
|
||||
)
|
||||
|
||||
libunibreak = declare_dependency(
|
||||
include_directories: [include_directories('.')],
|
||||
link_with: libunibreak_lib,
|
||||
dependencies: [eina],
|
||||
)
|
||||
|
|
|
@ -53,27 +53,18 @@ _timer2_cb(void *data)
|
|||
timer->num_elem = 0;
|
||||
|
||||
// check add/delay timer 2
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(timer->add_timer2 > 1, "Error add/delay timer");
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
// check set new delay for timer 1
|
||||
ecore_timer_delay(timer->timer1, timer->delay_1[timer->num_elem]);
|
||||
|
||||
// check set new interval for timer 1
|
||||
ecore_timer_interval_set(timer->timer1, timer->interval_1[timer->num_elem]);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!EINA_DBL_EQ(timer->interval_1[timer->num_elem], ecore_timer_interval_get(timer->timer1)), "Error set new interval");
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
// check set new precision
|
||||
ecore_timer_precision_set(timer->precision[timer->num_elem]);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!EINA_DBL_EQ(timer->precision[timer->num_elem], ecore_timer_precision_get()), "Error set new precision");
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
// check removal timer 2
|
||||
if (ecore_timer_del(timer->timer2))
|
||||
|
@ -109,10 +100,7 @@ _timer4_cb(void *data)
|
|||
// check frezze/thaw timer 3
|
||||
if (freeze_thaw)
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(timer->check_freeze_thaw_timer3 != timer->count_timer3, "Error frezze/thaw timer");
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
ecore_timer_thaw(timer->timer3);
|
||||
freeze_thaw = 0;
|
||||
|
@ -165,10 +153,7 @@ EFL_START_TEST(ecore_test_timers)
|
|||
timer.timer4 = ecore_timer_add(TIMEOUT_4, _timer4_cb, &timer);
|
||||
timer.timer5 = ecore_timer_add(TIMEOUT_5, _timer5_cb, &timer);
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if((!timer.timer1 || !timer.timer2 || !timer.timer3 || !timer.timer4 || !timer.timer5), "Error add timer\n");
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
ecore_main_loop_begin();
|
||||
|
||||
|
@ -222,10 +207,7 @@ EFL_START_TEST(ecore_test_timer_inside_call)
|
|||
c->t = ecore_timer_add(0.01, _timeri_cb, c);
|
||||
ecore_timer_add(1.0, timeout_timer_cb, NULL);
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!c->t, "Error add timer\n");
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
ecore_main_loop_begin();
|
||||
}
|
||||
|
@ -235,10 +217,7 @@ EFL_END_TEST
|
|||
EFL_START_TEST(ecore_test_timer_valid_callbackfunc)
|
||||
{
|
||||
Ecore_Timer *t = NULL;
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if((t = ecore_timer_add(0.5, NULL, NULL)), "ERROR: Invalid callback func!\n");
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
EFL_END_TEST
|
||||
|
||||
|
@ -280,10 +259,7 @@ _timer_cb(void *data)
|
|||
{
|
||||
count++;
|
||||
int num = (intptr_t) data;
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if (num != count, "Error timer is called out of order");
|
||||
#pragma GCC diagnostic pop
|
||||
if (count == 8) ecore_main_loop_quit();
|
||||
return ECORE_CALLBACK_CANCEL;
|
||||
}
|
||||
|
|
|
@ -110,11 +110,9 @@ efl_app_suite = executable('efl_app_suite',
|
|||
)
|
||||
|
||||
test('ecore-suite', ecore_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
||||
test('efl-app', efl_app_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -172,16 +172,13 @@ _assert_found_internal(const char *file, int line, const struct resolve_ctx *ctx
|
|||
unsigned int i, len;
|
||||
const Efl_Net_Ip_Address *o;
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
if (ctx->err != err)
|
||||
if (ctx->err != err)
|
||||
_ck_assert_failed(file, line, "Failed",
|
||||
"Expected error=%d (%s), got %d (%s) resolving=%s",
|
||||
err, err ? eina_error_msg_get(err) : "success",
|
||||
ctx->err, ctx->err ? eina_error_msg_get(ctx->err) : "success",
|
||||
string,
|
||||
NULL);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
if (err) return;
|
||||
|
||||
|
@ -194,14 +191,11 @@ _assert_found_internal(const char *file, int line, const struct resolve_ctx *ctx
|
|||
EINA_VALUE_ARRAY_FOREACH(ctx->results, len, i, o)
|
||||
fprintf(stderr, "result %u: %s\n", i, efl_net_ip_address_string_get(o));
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
_ck_assert_failed(file, line, "Failed",
|
||||
"Expected found=%hhu, got %hhu resolving=%s",
|
||||
expected, found,
|
||||
string,
|
||||
NULL);
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
|
||||
static Eina_Value
|
||||
|
|
|
@ -16,6 +16,5 @@ ecore_con_suite = executable('ecore_con_suite',
|
|||
)
|
||||
|
||||
test('ecore_con-suite', ecore_con_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -27,6 +27,5 @@ ecore_wl2_suite = executable('ecore_wl2_suite',
|
|||
)
|
||||
|
||||
test('ecore_wl2-suite', ecore_wl2_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -25,6 +25,5 @@ edje_suite = executable('edje_suite',
|
|||
)
|
||||
|
||||
test('edje-suite', edje_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -23,6 +23,5 @@ eet_suite = executable('eet_suite',
|
|||
)
|
||||
|
||||
test('eet-suite', eet_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -16,6 +16,5 @@ eeze_suite = executable('eeze_suite',
|
|||
)
|
||||
|
||||
test('eeze-suite', eeze_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -14,6 +14,5 @@ efl_suite_bin = executable('efl_suite',
|
|||
)
|
||||
|
||||
test('efl-suite', efl_suite_bin,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -306,9 +306,9 @@ _efl_suite_wait_on_fork(int *num_forks, Eina_Bool *timeout)
|
|||
ret = WEXITSTATUS(status);
|
||||
else
|
||||
ret = 1;
|
||||
if ((timeout_pid > 0) && (pid == timeout_pid))
|
||||
if (pid == timeout_pid)
|
||||
*timeout = EINA_TRUE;
|
||||
else if (timeout_pid > 0)
|
||||
else
|
||||
{
|
||||
eina_hash_del_by_key(fork_map, &pid);
|
||||
(*num_forks)--;
|
||||
|
@ -374,26 +374,8 @@ _efl_suite_build_and_run(int argc, const char **argv, const char *suite_name, co
|
|||
if (!timeout_pid)
|
||||
{
|
||||
timeout_pid = fork();
|
||||
if (timeout_pid == 0)
|
||||
{
|
||||
int ret = execl(PACKAGE_BUILD_DIR "/src/tests/timeout",
|
||||
PACKAGE_BUILD_DIR "/src/tests/timeout",
|
||||
(char *)NULL);
|
||||
if (ret != 0)
|
||||
{
|
||||
fprintf(stderr, "EXECL %s TO RUN TIMEOUT!!!\n", PACKAGE_BUILD_DIR "/src/tests/timeout");
|
||||
perror("EXECL");
|
||||
fflush(stderr);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
else if (timeout_pid < 0)
|
||||
{
|
||||
fprintf(stderr, "FORK TO RUN TIMEOUT TOOL FAILED!!!\n");
|
||||
perror("FORK");
|
||||
fflush(stderr);
|
||||
abort();
|
||||
}
|
||||
if (!timeout_pid)
|
||||
execl("/bin/sh", "/bin/sh", "-c", PACKAGE_BUILD_DIR "/src/tests/timeout", (char *)NULL);
|
||||
}
|
||||
if (num_forks == eina_cpu_count())
|
||||
failed_count += _efl_suite_wait_on_fork(&num_forks, &timeout_reached);
|
||||
|
@ -410,13 +392,6 @@ _efl_suite_build_and_run(int argc, const char **argv, const char *suite_name, co
|
|||
# endif
|
||||
continue;
|
||||
}
|
||||
else if (pid < 0)
|
||||
{
|
||||
fprintf(stderr, "FORK TO RUN TIMEOUT TOOL FAILED!!!\n");
|
||||
perror("FORK");
|
||||
fflush(stderr);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
@ -15,8 +15,7 @@ efreet_suite = executable('efreet_suite',
|
|||
)
|
||||
|
||||
test('efreet-suite', efreet_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
||||
efreet_test_src = [
|
||||
|
|
|
@ -551,9 +551,8 @@ static const struct {
|
|||
{ "C:\\home\\mydir\\..\\myfile", "C:/home/myfile" },
|
||||
{ "C:/home/mydir/../myfile", "C:/home/myfile" },
|
||||
{ "\\home\\mydir\\..\\myfile", "/home/myfile" },
|
||||
#else
|
||||
{ "/home/mydir/../myfile", "/home/myfile" }
|
||||
#endif
|
||||
{ "/home/mydir/../myfile", "/home/myfile" }
|
||||
};
|
||||
|
||||
EFL_START_TEST(eina_test_file_path)
|
||||
|
@ -897,48 +896,6 @@ EFL_START_TEST(eina_test_file_unlink)
|
|||
}
|
||||
EFL_END_TEST
|
||||
|
||||
EFL_START_TEST(eina_test_file_access)
|
||||
{
|
||||
typedef struct
|
||||
{
|
||||
const char *path;
|
||||
Eina_File_Access_Mode mode;
|
||||
Eina_Bool expected;
|
||||
} Paths;
|
||||
|
||||
Paths paths[] = {
|
||||
#ifdef _WIN32
|
||||
{ "c:\\Windows", EINA_FILE_ACCESS_MODE_EXIST, EINA_TRUE },
|
||||
{ "c:\\Windows", EINA_FILE_ACCESS_MODE_EXEC, EINA_TRUE },
|
||||
{ "c:\\Windows\\notepad.exe", EINA_FILE_ACCESS_MODE_EXIST, EINA_TRUE },
|
||||
{ "c:\\Windows\\notepad.exe", EINA_FILE_ACCESS_MODE_EXEC, EINA_TRUE },
|
||||
{ "c:\\Windows\\notepad.exe", EINA_FILE_ACCESS_MODE_WRITE, EINA_TRUE },
|
||||
{ "c:\\Windows\\notepad.exe", EINA_FILE_ACCESS_MODE_READ, EINA_TRUE },
|
||||
#else
|
||||
{ "/usr", EINA_FILE_ACCESS_MODE_EXIST, EINA_TRUE },
|
||||
{ "/usr", EINA_FILE_ACCESS_MODE_EXEC, EINA_TRUE },
|
||||
{ "/usr", EINA_FILE_ACCESS_MODE_READ, EINA_TRUE },
|
||||
{ "/root", EINA_FILE_ACCESS_MODE_WRITE, EINA_FALSE },
|
||||
#endif
|
||||
{ NULL, EINA_FILE_ACCESS_MODE_EXIST, EINA_FALSE },
|
||||
};
|
||||
size_t i;
|
||||
Eina_Bool result;
|
||||
|
||||
result = eina_file_access(NULL, EINA_FILE_ACCESS_MODE_EXIST);
|
||||
fail_if(result == EINA_TRUE);
|
||||
|
||||
result = eina_file_access("", EINA_FILE_ACCESS_MODE_EXIST);
|
||||
fail_if(result == EINA_TRUE);
|
||||
|
||||
for (i = 0; paths[i].path; i++)
|
||||
{
|
||||
result = eina_file_access(paths[i].path, paths[i].mode);
|
||||
fail_if(result != paths[i].expected);
|
||||
}
|
||||
}
|
||||
EFL_END_TEST
|
||||
|
||||
void
|
||||
eina_test_file(TCase *tc)
|
||||
{
|
||||
|
@ -956,5 +913,5 @@ eina_test_file(TCase *tc)
|
|||
tcase_add_test(tc, eina_test_file_statat);
|
||||
tcase_add_test(tc, eina_test_file_mktemp);
|
||||
tcase_add_test(tc, eina_test_file_unlink);
|
||||
tcase_add_test(tc, eina_test_file_access);
|
||||
|
||||
}
|
||||
|
|
|
@ -59,30 +59,27 @@ _test_free(Eina_Lazy_Allocator_Test *elat)
|
|||
|
||||
EFL_START_TEST(eina_lalloc_simple)
|
||||
{
|
||||
Eina_Lazy_Allocator_Test *elat;
|
||||
Eina_Lalloc *test;
|
||||
int i;
|
||||
Eina_Lazy_Allocator_Test *elat;
|
||||
Eina_Lalloc *test;
|
||||
int i;
|
||||
|
||||
elat = calloc(1, sizeof (Eina_Lazy_Allocator_Test));
|
||||
fail_if(!elat);
|
||||
elat = calloc(1, sizeof (Eina_Lazy_Allocator_Test));
|
||||
fail_if(!elat);
|
||||
|
||||
test = eina_lalloc_new(elat,
|
||||
EINA_LALLOC_ALLOC(_test_alloc),
|
||||
EINA_LALLOC_FREE(_test_free), 10);
|
||||
fail_if(!test);
|
||||
test = eina_lalloc_new(elat, EINA_LALLOC_ALLOC(
|
||||
_test_alloc), EINA_LALLOC_FREE(_test_free), 10);
|
||||
fail_if(!test);
|
||||
|
||||
for (i = 0; i < 10; ++i)
|
||||
fail_if(eina_lalloc_element_add(test) != EINA_TRUE);
|
||||
for (i = 0; i < 10; ++i)
|
||||
fail_if(eina_lalloc_element_add(test) != EINA_TRUE);
|
||||
fail_if(eina_lalloc_element_add(test) != EINA_FALSE);
|
||||
fail_if(eina_lalloc_elements_add(test, 5) != EINA_TRUE);
|
||||
for (i = 0; i < 21; ++i)
|
||||
fail_if(eina_lalloc_element_add(test) != EINA_TRUE);
|
||||
|
||||
fail_if(eina_lalloc_element_add(test) != EINA_FALSE);
|
||||
fail_if(eina_lalloc_elements_add(test, 5) != EINA_TRUE);
|
||||
fail_if(eina_lalloc_elements_add(test, 50) != EINA_FALSE);
|
||||
|
||||
for (i = 0; i < 21; ++i)
|
||||
fail_if(eina_lalloc_element_add(test) != EINA_TRUE);
|
||||
|
||||
fail_if(eina_lalloc_elements_add(test, 50) != EINA_FALSE);
|
||||
|
||||
eina_lalloc_free(test);
|
||||
eina_lalloc_free(test);
|
||||
}
|
||||
EFL_END_TEST
|
||||
|
||||
|
|
|
@ -219,85 +219,84 @@ EFL_END_TEST
|
|||
|
||||
EFL_START_TEST(eina_test_list_merge)
|
||||
{
|
||||
Eina_List *l1;
|
||||
Eina_List *l2;
|
||||
Eina_List *l3;
|
||||
Eina_List *l4;
|
||||
Eina_List *l5;
|
||||
int data[] = { 6, 9, 42, 1, 7, 9, 81, 1664, 1337, 3, 21, 10, 0, 5, 2008 };
|
||||
int i;
|
||||
Eina_List *l1;
|
||||
Eina_List *l2;
|
||||
Eina_List *l3;
|
||||
Eina_List *l4;
|
||||
Eina_List *l5;
|
||||
int data[] = { 6, 9, 42, 1, 7, 9, 81, 1664, 1337, 3, 21, 10, 0, 5, 2008 };
|
||||
int i;
|
||||
|
||||
|
||||
l1 = eina_list_append(NULL, &data[0]);
|
||||
l1 = eina_list_append(l1, &data[1]);
|
||||
l1 = eina_list_append(l1, &data[2]);
|
||||
l1 = eina_list_append(l1, &data[3]);
|
||||
fail_if(l1 == NULL);
|
||||
l1 = eina_list_append(NULL, &data[0]);
|
||||
l1 = eina_list_append(l1, &data[1]);
|
||||
l1 = eina_list_append(l1, &data[2]);
|
||||
l1 = eina_list_append(l1, &data[3]);
|
||||
fail_if(l1 == NULL);
|
||||
|
||||
l2 = eina_list_append(NULL, &data[4]);
|
||||
l2 = eina_list_append(l2, &data[5]);
|
||||
fail_if(l2 == NULL);
|
||||
l2 = eina_list_append(NULL, &data[4]);
|
||||
l2 = eina_list_append(l2, &data[5]);
|
||||
fail_if(l2 == NULL);
|
||||
|
||||
l1 = eina_list_merge(l1, l2);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 6);
|
||||
for (i = 0, l2 = l1; ((l2 != NULL) && (i < 6)); ++i, l2 = l2->next)
|
||||
fail_if(l2->data != &data[i]);
|
||||
l1 = eina_list_merge(l1, l2);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 6);
|
||||
for (i = 0, l2 = l1; ((l2 != NULL) && (i < 6)); ++i, l2 = l2->next)
|
||||
fail_if(l2->data != &data[i]);
|
||||
fail_if(i != 6);
|
||||
fail_if(l2 != NULL);
|
||||
|
||||
fail_if(i != 6);
|
||||
fail_if(l2 != NULL);
|
||||
eina_list_free(l1);
|
||||
|
||||
eina_list_free(l1);
|
||||
l1 = eina_list_append(NULL, &data[0]);
|
||||
l1 = eina_list_append(l1, &data[1]);
|
||||
fail_if(l1 == NULL);
|
||||
|
||||
l1 = eina_list_append(NULL, &data[0]);
|
||||
l1 = eina_list_append(l1, &data[1]);
|
||||
fail_if(l1 == NULL);
|
||||
l2 = eina_list_append(NULL, &data[2]);
|
||||
l2 = eina_list_append(l2, &data[3]);
|
||||
l2 = eina_list_append(l2, &data[4]);
|
||||
l2 = eina_list_append(l2, &data[5]);
|
||||
fail_if(l2 == NULL);
|
||||
|
||||
l2 = eina_list_append(NULL, &data[2]);
|
||||
l2 = eina_list_append(l2, &data[3]);
|
||||
l2 = eina_list_append(l2, &data[4]);
|
||||
l2 = eina_list_append(l2, &data[5]);
|
||||
fail_if(l2 == NULL);
|
||||
l1 = eina_list_merge(l1, l2);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 6);
|
||||
for (i = 0, l2 = l1; ((l2 != NULL) && (i < 6)); ++i, l2 = l2->next)
|
||||
fail_if(l2->data != &data[i]);
|
||||
fail_if(i != 6);
|
||||
fail_if(l2 != NULL);
|
||||
|
||||
l1 = eina_list_merge(l1, l2);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 6);
|
||||
for (i = 0, l2 = l1; ((l2 != NULL) && (i < 6)); ++i, l2 = l2->next)
|
||||
fail_if(l2->data != &data[i]);
|
||||
l3 = eina_list_append(NULL, &data[6]);
|
||||
l3 = eina_list_append(l3, &data[7]);
|
||||
l3 = eina_list_append(l3, &data[8]);
|
||||
|
||||
fail_if(i != 6);
|
||||
fail_if(l2 != NULL);
|
||||
l4 = eina_list_append(NULL, &data[9]);
|
||||
l4 = eina_list_append(l4, &data[10]);
|
||||
l4 = eina_list_append(l4, &data[11]);
|
||||
|
||||
l3 = eina_list_append(NULL, &data[6]);
|
||||
l3 = eina_list_append(l3, &data[7]);
|
||||
l3 = eina_list_append(l3, &data[8]);
|
||||
l5 = eina_list_append(NULL, &data[12]);
|
||||
l5 = eina_list_append(l5, &data[13]);
|
||||
l5 = eina_list_append(l5, &data[14]);
|
||||
|
||||
l4 = eina_list_append(NULL, &data[9]);
|
||||
l4 = eina_list_append(l4, &data[10]);
|
||||
l4 = eina_list_append(l4, &data[11]);
|
||||
l1 = eina_list_sort(l1, -1, eina_int_cmp);
|
||||
l3 = eina_list_sort(l3, -1, eina_int_cmp);
|
||||
l4 = eina_list_sort(l4, -1, eina_int_cmp);
|
||||
l5 = eina_list_sort(l5, -1, eina_int_cmp);
|
||||
|
||||
l5 = eina_list_append(NULL, &data[12]);
|
||||
l5 = eina_list_append(l5, &data[13]);
|
||||
l5 = eina_list_append(l5, &data[14]);
|
||||
l1 = eina_list_sorted_merge(l1, l3, eina_int_cmp);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 9);
|
||||
|
||||
l1 = eina_list_sort(l1, -1, eina_int_cmp);
|
||||
l3 = eina_list_sort(l3, -1, eina_int_cmp);
|
||||
l4 = eina_list_sort(l4, -1, eina_int_cmp);
|
||||
l5 = eina_list_sort(l5, -1, eina_int_cmp);
|
||||
l1 = eina_list_sorted_merge(l1, l4, eina_int_cmp);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 12);
|
||||
|
||||
l1 = eina_list_sorted_merge(l1, l3, eina_int_cmp);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 9);
|
||||
l1 = eina_list_sorted_merge(l1, l5, eina_int_cmp);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 15);
|
||||
|
||||
l1 = eina_list_sorted_merge(l1, l4, eina_int_cmp);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 12);
|
||||
fail_if(!eina_list_sorted_check(l1));
|
||||
|
||||
l1 = eina_list_sorted_merge(l1, l5, eina_int_cmp);
|
||||
fail_if(l1 == NULL);
|
||||
fail_if(eina_list_count(l1) != 15);
|
||||
|
||||
fail_if(!eina_list_sorted_check(l1));
|
||||
}
|
||||
EFL_END_TEST
|
||||
|
||||
|
|
|
@ -93,11 +93,6 @@ EFL_START_TEST(eina_value_test_simple)
|
|||
fail_unless(l == 0xb33f);
|
||||
eina_value_flush(value);
|
||||
|
||||
/*
|
||||
* On Windows, long is always a 4 bytes type, so this check
|
||||
* will never work on Windows.
|
||||
*/
|
||||
#ifndef _WIN32
|
||||
fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_INT64));
|
||||
fail_unless(eina_value_set(value, 0x0011223344556677));
|
||||
fail_unless(eina_value_get(value, &i64));
|
||||
|
@ -108,7 +103,6 @@ EFL_START_TEST(eina_value_test_simple)
|
|||
fail_unless(l == (long)0x0011223344556677);
|
||||
fail_unless(i64 == 0x0011223344556677);
|
||||
eina_value_flush(value);
|
||||
#endif
|
||||
|
||||
/* unsigned: */
|
||||
|
||||
|
@ -156,11 +150,6 @@ EFL_START_TEST(eina_value_test_simple)
|
|||
fail_unless(ul == 3000000001UL);
|
||||
eina_value_flush(value);
|
||||
|
||||
/*
|
||||
* On Windows, long is always a 4 bytes type, so this check
|
||||
* will never work on Windows.
|
||||
*/
|
||||
#ifndef _WIN32
|
||||
fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UINT64));
|
||||
fail_unless(eina_value_set(value, 0x1122334455667788));
|
||||
fail_unless(eina_value_get(value, &u64));
|
||||
|
@ -171,7 +160,6 @@ EFL_START_TEST(eina_value_test_simple)
|
|||
fail_unless(ul == (unsigned long)0x1122334455667788);
|
||||
fail_unless(u64 == 0x1122334455667788);
|
||||
eina_value_flush(value);
|
||||
#endif
|
||||
|
||||
/* floating point */
|
||||
fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_FLOAT));
|
||||
|
@ -2357,22 +2345,13 @@ EFL_START_TEST(eina_value_test_hash)
|
|||
fail_unless(str != NULL);
|
||||
|
||||
snprintf(buf, sizeof(buf), "first: %d", (int) '!');
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
snprintf(buf, sizeof(buf), "second: %d", (int) '-');
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
snprintf(buf, sizeof(buf), "third: %d", (int) 's');
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
free(str);
|
||||
|
||||
|
@ -2389,34 +2368,19 @@ EFL_START_TEST(eina_value_test_hash)
|
|||
fail_unless(str != NULL);
|
||||
|
||||
eina_strlcpy(buf, "a: Enlightenment.org", sizeof(buf));
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
eina_strlcpy(buf, "b: X11", sizeof(buf));
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
eina_strlcpy(buf, "c: Pants", sizeof(buf));
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
eina_strlcpy(buf, "d: on!!!", sizeof(buf));
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
eina_strlcpy(buf, "e: k-s", sizeof(buf));
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
free(str);
|
||||
|
||||
|
|
|
@ -72,5 +72,4 @@ eina_test_exe = executable('eina_suite',
|
|||
|
||||
test('eina', eina_test_exe,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
)
|
||||
|
|
|
@ -168,10 +168,7 @@ EFL_START_TEST(efl_io_model_test_test_file)
|
|||
|
||||
filemodel = efl_add(EFL_IO_MODEL_CLASS, efl_main_loop_get(),
|
||||
efl_io_model_path_set(efl_added, EFL_MODEL_TEST_FILENAME_PATH));
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!filemodel, "ERROR: Cannot init model!\n");
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL);
|
||||
|
||||
|
|
|
@ -172,10 +172,7 @@ EFL_START_TEST(efl_io_model_test_test_monitor_add)
|
|||
filemodel = efl_add(EFL_IO_MODEL_CLASS,
|
||||
efl_main_loop_get(),
|
||||
efl_io_model_path_set(efl_added, tmpdir));
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!filemodel, "ERROR: Cannot init model!\n");
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
efl_event_callback_add(filemodel, EFL_MODEL_EVENT_CHILD_ADDED, &_children_added_cb, filemodel);
|
||||
efl_event_callback_add(filemodel, EFL_MODEL_EVENT_CHILD_REMOVED, &_children_removed_cb, NULL);
|
||||
|
|
|
@ -26,5 +26,5 @@ eio_suite = executable('eio_suite',
|
|||
|
||||
test('eio-suite', eio_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
timeout : 120
|
||||
)
|
||||
|
|
|
@ -29,5 +29,4 @@ eldbus_suite = executable('eldbus_suite',
|
|||
|
||||
test('eldbus-suite', eldbus_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
)
|
||||
|
|
|
@ -500,7 +500,6 @@ EFL_START_TEST(order_check)
|
|||
}
|
||||
EFL_END_TEST
|
||||
|
||||
/* this is not working - but doesn't affect anything in real life
|
||||
EFL_START_TEST(logical_shift)
|
||||
{
|
||||
Efl_Ui_Focus_Manager *m;
|
||||
|
@ -531,7 +530,6 @@ EFL_START_TEST(logical_shift)
|
|||
efl_unref(m);
|
||||
}
|
||||
EFL_END_TEST
|
||||
*/
|
||||
|
||||
EFL_START_TEST(root_redirect_chain)
|
||||
{
|
||||
|
@ -1097,7 +1095,7 @@ void efl_ui_test_focus(TCase *tc)
|
|||
tcase_add_test(tc, redirect_param);
|
||||
tcase_add_test(tc, invalid_args_check);
|
||||
tcase_add_test(tc, order_check);
|
||||
// tcase_add_test(tc, logical_shift);
|
||||
tcase_add_test(tc, logical_shift);
|
||||
tcase_add_test(tc, root_redirect_chain);
|
||||
tcase_add_test(tc, root_redirect_chain_unset);
|
||||
tcase_add_test(tc, first_touch_check);
|
||||
|
|
|
@ -30,7 +30,7 @@ static const Efl_Test_Case etc[] = {
|
|||
{ "elm_prefs", elm_test_prefs},
|
||||
{ "elm_map", elm_test_map},
|
||||
{ "elm_glview", elm_test_glview},
|
||||
// { "elm_web", elm_test_web},
|
||||
{ "elm_web", elm_test_web},
|
||||
{ "elm_toolbar", elm_test_toolbar},
|
||||
{ "elm_grid", elm_test_grid},
|
||||
{ "elm_diskselector", elm_test_diskselector},
|
||||
|
|
|
@ -26,7 +26,6 @@ EFL_START_TEST(elm_video_legacy_type_check)
|
|||
}
|
||||
EFL_END_TEST
|
||||
|
||||
/*
|
||||
EFL_START_TEST(elm_atspi_role_get)
|
||||
{
|
||||
Evas_Object *win, *video;
|
||||
|
@ -41,7 +40,6 @@ EFL_START_TEST(elm_atspi_role_get)
|
|||
|
||||
}
|
||||
EFL_END_TEST
|
||||
*/
|
||||
|
||||
void elm_test_video(TCase *tc)
|
||||
{
|
||||
|
|
|
@ -6,7 +6,6 @@
|
|||
#include <Elementary.h>
|
||||
#include "elm_suite.h"
|
||||
|
||||
/*
|
||||
EFL_START_TEST(elm_web_legacy_type_check)
|
||||
{
|
||||
Evas_Object *win, *web;
|
||||
|
@ -47,4 +46,3 @@ void elm_test_web(TCase *tc)
|
|||
tcase_add_test(tc, elm_web_legacy_type_check);
|
||||
tcase_add_test(tc, elm_atspi_role_get);
|
||||
}
|
||||
*/
|
||||
|
|
|
@ -193,13 +193,11 @@ executable('efl_ui_window_cnp_dnd_slave',
|
|||
)
|
||||
|
||||
test('elementary-suite', elementary_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
||||
test('efl-ui-suite', efl_ui_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
||||
install_data(files(['testdiff.diff', 'testfile-windows.txt', 'testfile-withblanks.txt', 'testfile.txt']),
|
||||
|
|
|
@ -45,5 +45,5 @@ efl_ui_behavior_suite = executable('efl_ui_spec_suite',
|
|||
|
||||
test('efl_ui_spec-suite', efl_ui_behavior_suite,
|
||||
env : test_env,
|
||||
timeout: master_timeout
|
||||
timeout: 60
|
||||
)
|
||||
|
|
|
@ -14,6 +14,5 @@ emile_suite = executable('emile_suite',
|
|||
)
|
||||
|
||||
test('emile-suite', emile_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -991,7 +991,7 @@ EFL_START_TEST(eo_magic_checks)
|
|||
simple_a_set((Efl_Class *) buf, 1);
|
||||
simple_a_set(efl_super((Efl_Class *) buf, SIMPLE_CLASS), ++i);
|
||||
simple_a_set(efl_super(SIMPLE_CLASS, (Efl_Class *) buf), ++i);
|
||||
fail_if(efl_class_new(NULL, (Efl_Class *) buf));
|
||||
fail_if(efl_class_new(NULL, (Efl_Class *) buf), NULL);
|
||||
|
||||
efl_xref(obj, (Eo *) buf);
|
||||
efl_xunref(obj, (Eo *) buf);
|
||||
|
|
|
@ -30,8 +30,7 @@ eo_suite = executable('eo_suite',
|
|||
)
|
||||
|
||||
test('eo-suite', eo_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
||||
eo_suite = executable('eo_suite_dbg',
|
||||
|
@ -44,8 +43,7 @@ eo_suite = executable('eo_suite_dbg',
|
|||
)
|
||||
|
||||
test('eo-suite-dbg', eo_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
||||
eo_suite = executable('eo_suite_fallback',
|
||||
|
@ -59,6 +57,5 @@ eo_suite = executable('eo_suite_fallback',
|
|||
)
|
||||
|
||||
test('eo-suite-fallback', eo_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
env : test_env
|
||||
)
|
||||
|
|
|
@ -151,18 +151,12 @@ EFL_START_TEST(evas_filter_parser)
|
|||
fprintf(stderr, "Evas filters tests: end of invalid cases.\n");
|
||||
evas_filter_program_del(pgm);
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
for (int k = 0; good[k]; k++)
|
||||
CHKGOOD(good[k]);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
fprintf(stderr, "Evas filters tests: start invalid cases. Ignore the following ERRs.\n");
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
for (int k = 0; bad[k]; k++)
|
||||
CHKBAAD(bad[k]);
|
||||
#pragma GCC diagnostic pop
|
||||
fprintf(stderr, "Evas filters tests: end of invalid cases.\n");
|
||||
|
||||
// All colors -- FIXME: need to check actual color value
|
||||
|
@ -199,10 +193,7 @@ EFL_START_TEST(evas_filter_parser)
|
|||
{
|
||||
char buf[64];
|
||||
sprintf(buf, "blend { color = '%s' }", colors[c]);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
CHKGOOD(buf);
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
|
||||
// fillmodes are parsed when converting from instructions to commands
|
||||
|
@ -241,9 +232,8 @@ static struct Filter_Test_Case _test_cases[] = {
|
|||
|
||||
{ 0, 0, 0, 0, "a = buffer ({ 'alpha' }) blend ({ dst = a }) curve ({ '0:0-255:255', src = a,dst = a }) blend ({ a })", NULL },
|
||||
{ 0, 0, 0, 0, "a = buffer ({ 'alpha' }) blend ({ dst = a }) curve ({ '0:0-255:255',dst = a }) blend ({ a })", NULL },
|
||||
// these are broken - why? it's not the interpolation...
|
||||
// { 0, 0, 0, 0, "a = buffer ({ 'rgba' }) blend ({ dst = a }) curve ({ '0:0-255:255', src = a, channel = 'r' })", NULL },
|
||||
// { 0, 0, 0, 0, "a = buffer ({ 'rgba' }) blend ({ dst = a }) curve ({ '0:128-128:0', src = a, channel = 'rgb', interpolation = 'none' })", NULL },
|
||||
{ 0, 0, 0, 0, "a = buffer ({ 'rgba' }) blend ({ dst = a }) curve ({ '0:0-255:255', src = a, channel = 'r' })", NULL },
|
||||
{ 0, 0, 0, 0, "a = buffer ({ 'rgba' }) blend ({ dst = a }) curve ({ '0:128-128:0', src = a, channel = 'rgb', interpolation = 'none' })", NULL },
|
||||
|
||||
{ 0, 0, 0, 0, "fill ({ color = 'red' })", NULL },
|
||||
|
||||
|
@ -312,13 +302,10 @@ EFL_START_TEST(evas_filter_text_padding_test)
|
|||
evas_object_geometry_get(to, NULL, NULL, &W, &H);
|
||||
//fprintf(stderr, "Case %d: %dx%d for padding %d,%d,%d,%d\n", k, W, H, l, r, t, b);
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if((l != tc->l) || (r != tc->r) || (t != tc->t) || (b != tc->b),
|
||||
"Failed on invalid padding with '%s'\n", tc->code);
|
||||
fail_if((W != (tc->l + tc->r + w)) || (H != (tc->t + tc->b + h)),
|
||||
"Failed on invalid geometry with '%s'\n", tc->code);
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
|
||||
END_FILTER_TEST();
|
||||
|
@ -346,19 +333,11 @@ _ecore_evas_pixels_check(Ecore_Evas *ee)
|
|||
DATA8 *rgba = (DATA8 *) pixels;
|
||||
|
||||
if (*pixels && (*pixels != 0xFF000000)) nonzero = EINA_TRUE;
|
||||
if (rgba[ALPHA] < rgba[RED])
|
||||
if ((rgba[ALPHA] < rgba[RED])
|
||||
|| (rgba[ALPHA] < rgba[GREEN])
|
||||
|| (rgba[ALPHA] < rgba[BLUE]))
|
||||
{
|
||||
fprintf(stderr, "Invalid RGBA R value! must %i < %i\n", rgba[ALPHA], rgba[RED]);
|
||||
return EINA_FALSE;
|
||||
}
|
||||
if (rgba[ALPHA] < rgba[GREEN])
|
||||
{
|
||||
fprintf(stderr, "Invalid RGBA G value! must %i < %i\n", rgba[ALPHA], rgba[GREEN]);
|
||||
return EINA_FALSE;
|
||||
}
|
||||
if (rgba[ALPHA] < rgba[BLUE])
|
||||
{
|
||||
fprintf(stderr, "Invalid RGBA B value! must %i < %i\n", rgba[ALPHA], rgba[BLUE]);
|
||||
fprintf(stderr, "Invalid RGBA values!\n");
|
||||
return EINA_FALSE;
|
||||
}
|
||||
}
|
||||
|
@ -396,10 +375,7 @@ EFL_START_TEST(evas_filter_text_render_test)
|
|||
struct Filter_Test_Case *tc = &(_test_cases[k]);
|
||||
w = h = 0;
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
CHKGOOD(tc->code);
|
||||
#pragma GCC diagnostic pop
|
||||
if (tc->source)
|
||||
{
|
||||
o = evas_object_rectangle_add(evas);
|
||||
|
@ -425,11 +401,8 @@ EFL_START_TEST(evas_filter_text_render_test)
|
|||
evas_object_resize(rect, w, h);
|
||||
|
||||
ecore_evas_manual_render(ee);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!_ecore_evas_pixels_check(ee),
|
||||
"Render test failed with: [%dx%d] '%s'", w, h, tc->code);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
evas_object_del(o);
|
||||
evas_object_del(rect);
|
||||
|
@ -471,28 +444,19 @@ EFL_START_TEST(evas_filter_state_test)
|
|||
/* check pixels */
|
||||
ecore_evas_manual_render(ee);
|
||||
pixels = ecore_evas_buffer_pixels_get(ee);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!pixels || (*pixels != 0xFFFF0000),
|
||||
"state render test failed: %p (%#x)", pixels, pixels ? *pixels : 0);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
efl_gfx_filter_state_get(to, &s1, &v1, &s2, &v2, &p);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_unless(strequal(s1, "state1") && strequal(s2, "state2") && EINA_DBL_EQ(v1, 0.0) && EINA_DBL_EQ(v2, 1.0) && EINA_DBL_EQ(p, 0.5),
|
||||
"got: %s %f %s %f %f", s1, v1, s2, v2, p);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
/* data test */
|
||||
efl_gfx_filter_data_set(to, "data", "{r=0, g=255, b=0, a=255}", 1);
|
||||
ecore_evas_manual_render(ee);
|
||||
pixels = ecore_evas_buffer_pixels_get(ee);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!pixels || (*pixels != 0xFF00FF00),
|
||||
"state render test failed: %p (%#x)", pixels, pixels ? *pixels : 0);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
END_FILTER_TEST();
|
||||
}
|
||||
|
|
|
@ -282,11 +282,8 @@ EFL_START_TEST(evas_object_image_loader_orientation)
|
|||
|
||||
r_d = evas_object_image_data_get(rot, EINA_FALSE);
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(res[i].compare_func(d, r_d, r_w, r_h),
|
||||
"Image orientation test failed: exif orientation flag: %s\n", res[i].desc);
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
|
||||
evas_object_del(orig);
|
||||
|
@ -335,11 +332,8 @@ EFL_START_TEST(evas_object_image_orient)
|
|||
|
||||
r_d = evas_object_image_data_get(orig, EINA_FALSE);
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(res[i].compare_func(d, r_d, r_w, r_h),
|
||||
"Image orientation test failed: orient flag: %s\n", res[i].desc);
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
|
||||
evas_object_del(orig);
|
||||
|
@ -628,11 +622,8 @@ EFL_START_TEST(evas_object_image_partially_load_orientation)
|
|||
evas_object_image_size_get(rot, &r_w, &r_h);
|
||||
fail_if(w * h != r_w * r_h);
|
||||
r_d = evas_object_image_data_get(rot, EINA_FALSE);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(res[i].compare_func(d, r_d, r_w, r_h),
|
||||
"Image orientation partially load test failed: exif orientation flag: %s\n", res[i].desc);
|
||||
#pragma GCC diagnostic pop
|
||||
evas_object_del(rot);
|
||||
}
|
||||
|
||||
|
@ -963,8 +954,6 @@ EFL_START_TEST(evas_object_image_map_unmap)
|
|||
orig = sorig.mem;
|
||||
|
||||
// first quarter: same image
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
for (y = 0; y < h / 4; y++)
|
||||
for (x = 0; x < w; x++)
|
||||
fail_if(orig[y*stride/4 + x] != dest[y*stride2/4+x], "pixels differ [1]");
|
||||
|
@ -994,7 +983,6 @@ EFL_START_TEST(evas_object_image_map_unmap)
|
|||
fail_if(dest[y*stride/4 + x] != 0xFF00FF00, "pixels differ [3]");
|
||||
fail_if(dest[(y+1)*stride/4 + x] != 0xFFFF0000, "pixels differ [4]");
|
||||
}
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
efl_gfx_buffer_unmap(o, sorig);
|
||||
efl_gfx_buffer_unmap(o2, sdest);
|
||||
|
@ -1137,26 +1125,7 @@ EFL_START_TEST(evas_object_image_9patch)
|
|||
|
||||
fail_if(r_w != 1024 || r_h != 1024);
|
||||
for (int i = 0; i < r_w * r_h; i++)
|
||||
{
|
||||
int pixa, pixr, pixg, pixb, refa, refr, refg, refb;
|
||||
|
||||
pixa = (d[i] >> 24) & 0xff;
|
||||
pixr = (d[i] >> 16) & 0xff;
|
||||
pixg = (d[i] >> 8) & 0xff;
|
||||
pixb = (d[i] ) & 0xff;
|
||||
refa = (r_d[i] >> 24) & 0xff;
|
||||
refr = (r_d[i] >> 16) & 0xff;
|
||||
refg = (r_d[i] >> 8) & 0xff;
|
||||
refb = (r_d[i] ) & 0xff;
|
||||
pixa = abs(pixa - refa);
|
||||
fail_if(pixa > 32);
|
||||
pixr = abs(pixr - refr);
|
||||
fail_if(pixr > 32);
|
||||
pixg = abs(pixg - refg);
|
||||
fail_if(pixg > 32);
|
||||
pixb = abs(pixb - refb);
|
||||
fail_if(pixb > 32);
|
||||
}
|
||||
fail_if(((d[i] - r_d[i]) & 0xF8F8F8F8) != 0);
|
||||
}
|
||||
|
||||
evas_object_del(obj);
|
||||
|
|
|
@ -250,7 +250,6 @@ EFL_START_TEST(evas_mask_test_compare_clip)
|
|||
EFL_END_TEST
|
||||
|
||||
// This will simply check that a mask is recursively applied to children
|
||||
/* this wasn't a ver goodvalid test to begin with... see comments
|
||||
EFL_START_TEST(evas_mask_test_mask_of_mask)
|
||||
{
|
||||
Evas_Object *bg, *tbl, *rect0, *mask0, *mask1, *obj;
|
||||
|
@ -371,7 +370,6 @@ EFL_START_TEST(evas_mask_test_mask_of_mask)
|
|||
END_MASK_TEST();
|
||||
}
|
||||
EFL_END_TEST
|
||||
*/
|
||||
|
||||
// NOTE: Much more extensive tests are required. But they should
|
||||
// be based on "exactness" or a pixel similarity tool.
|
||||
|
@ -381,8 +379,7 @@ void evas_test_mask(TCase *tc)
|
|||
{
|
||||
tcase_add_test(tc, evas_mask_test_setget);
|
||||
tcase_add_test(tc, evas_mask_test_compare_clip);
|
||||
/// I don't see how this ever worked? mask of masks...
|
||||
// tcase_add_test(tc, evas_mask_test_mask_of_mask);
|
||||
tcase_add_test(tc, evas_mask_test_mask_of_mask);
|
||||
}
|
||||
|
||||
#endif // BUILD_ENGINE_BUFFER
|
||||
|
|
|
@ -58,10 +58,7 @@ EFL_START_TEST(evas_render_engines)
|
|||
for (itr = built_engines; *itr != NULL; itr++)
|
||||
{
|
||||
Eina_Bool found = _find_list(lst, *itr);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(!found, "module should be built, but was not found: %s", *itr);
|
||||
#pragma GCC diagnostic pop
|
||||
fail_if(!found, "module should be built, but was not found: %s", *itr);
|
||||
}
|
||||
|
||||
evas_render_method_list_free(lst);
|
||||
|
@ -75,10 +72,7 @@ EFL_START_TEST(evas_render_lookup)
|
|||
for (itr = built_engines; *itr != NULL; itr++)
|
||||
{
|
||||
int id = evas_render_method_lookup(*itr);
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wformat-extra-args"
|
||||
fail_if(id == 0, "could not load engine: %s", *itr);
|
||||
#pragma GCC diagnostic pop
|
||||
}
|
||||
}
|
||||
EFL_END_TEST
|
||||
|
|
|
@ -35,5 +35,5 @@ evas_suite = executable('evas_suite',
|
|||
|
||||
test('evas-suite', evas_suite,
|
||||
env : test_env,
|
||||
timeout : master_timeout
|
||||
timeout: 60,
|
||||
)
|
||||
|
|
|
@ -1,2 +1 @@
|
|||
master_timeout = 240
|
||||
executable('timeout', 'timeout.c')
|
||||
|
|
|
@ -10,6 +10,6 @@
|
|||
int
|
||||
main(int arc, char *argv[])
|
||||
{
|
||||
sleep(240);
|
||||
sleep(60);
|
||||
return 0;
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue