From patchwork Mon Apr 6 16:25:18 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella X-Patchwork-Id: 46787 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-lb0-f197.google.com (mail-lb0-f197.google.com [209.85.217.197]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 077E8214B1 for ; Mon, 6 Apr 2015 16:25:48 +0000 (UTC) Received: by lbcne10 with SMTP id ne10sf6842949lbc.1 for ; Mon, 06 Apr 2015 09:25:47 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:mailing-list:precedence:list-id :list-unsubscribe:list-subscribe:list-archive:list-post:list-help :sender:delivered-to:message-id:date:from:user-agent:mime-version:to :subject:content-type:content-transfer-encoding:x-original-sender :x-original-authentication-results; bh=bHG2sjRCPQkCcHIMSt2+yk6SiCftI9TZnOX5N9nga6Y=; b=XUNkuRA/e6y53uBi072jLu86Xqb76yH5HwmUq2fyg8paPfCJYljbtaAgejIKDZHBq8 num58UcP1XcJCQSjJLUhCNorSrT3wHYDq9AYYPTnc84vkvQZP0W1omJajSqe7UF0dt0v ekmz+xLLfWHYLinzuWblY5hoAmIr8AGnZMQ34CjrMrP1fON1vOKDAPg6gh4RGL3NUdbD Fjo+MJLg1CczXfuX84bvnoNk+VfCXAMyMpxryIHqmXV+7BGN4+C/WP3ntHijv1GVXpRv yxenRljGaKn+421jX8dc+Sq0kbH94BYQVO0Yrp+W1IPoPDa5cXdOXha7KjO2zIavpuGu vukQ== X-Gm-Message-State: ALoCoQkF36TAXKLY+H91mk47lGE5k034ewjwTfFVNjriy6LarqoT7l/Qu3ax3SvRDQD1MAZISkBN X-Received: by 10.152.19.67 with SMTP id c3mr3282406lae.7.1428337546960; Mon, 06 Apr 2015 09:25:46 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.152.18.225 with SMTP id z1ls582601lad.109.gmail; Mon, 06 Apr 2015 09:25:46 -0700 (PDT) X-Received: by 10.152.234.169 with SMTP id uf9mr14361064lac.88.1428337546634; Mon, 06 Apr 2015 09:25:46 -0700 (PDT) Received: from mail-la0-x22b.google.com (mail-la0-x22b.google.com. [2a00:1450:4010:c03::22b]) by mx.google.com with ESMTPS id ut15si3900957lbb.101.2015.04.06.09.25.46 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 06 Apr 2015 09:25:46 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 2a00:1450:4010:c03::22b as permitted sender) client-ip=2a00:1450:4010:c03::22b; Received: by laat2 with SMTP id t2so16145581laa.1 for ; Mon, 06 Apr 2015 09:25:46 -0700 (PDT) X-Received: by 10.152.36.2 with SMTP id m2mr3383857laj.72.1428337546491; Mon, 06 Apr 2015 09:25:46 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.57.201 with SMTP id k9csp3448036lbq; Mon, 6 Apr 2015 09:25:45 -0700 (PDT) X-Received: by 10.66.185.230 with SMTP id ff6mr28966332pac.102.1428337544529; Mon, 06 Apr 2015 09:25:44 -0700 (PDT) Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id o2si7311214pds.107.2015.04.06.09.25.43 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 06 Apr 2015 09:25:44 -0700 (PDT) Received-SPF: pass (google.com: domain of libc-alpha-return-58320-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Received: (qmail 115696 invoked by alias); 6 Apr 2015 16:25:26 -0000 Mailing-List: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org Precedence: list List-Id: List-Unsubscribe: , List-Subscribe: List-Archive: List-Post: , List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 115648 invoked by uid 89); 6 Apr 2015 16:25:25 -0000 X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.3 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-qg0-f43.google.com X-Received: by 10.140.84.164 with SMTP id l33mr17672203qgd.11.1428337520681; Mon, 06 Apr 2015 09:25:20 -0700 (PDT) Message-ID: <5522B36E.8030805@linaro.org> Date: Mon, 06 Apr 2015 13:25:18 -0300 From: Adhemerval Zanella User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.6.0 MIME-Version: 1.0 To: libc-alpha@sourceware.org Subject: [PATCH 2/2] libio: Update tst-fmemopen2.c X-Original-Sender: adhemerval.zanella@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 2a00:1450:4010:c03::22b as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org; dkim=pass header.i=@sourceware.org X-Google-Group-Id: 836684582541 Hi, This is reposting of a old thread back in February [1], with the fixes Joseph has raised in last review thread. This patch updates tst-fmemopen2 to check for fmemopen with NULL buffer inputs and also refactor the code a bit. The test relies on a POSIX compliant fmemopen implementation. Tested on x86_64, i386, and arm-linux-gnueabihf. [1] https://sourceware.org/ml/libc-alpha/2015-02/msg00280.html --- 2015-06-04 Adhemerval Zanella * stdio-common/tst-fmemopen2.c (do_test): Add test for NULL and zero length buffers. * stdio-common/tst-fmemopen.c (do_test): Refactor to use test-skeleton.c. --- diff --git a/stdio-common/tst-fmemopen2.c b/stdio-common/tst-fmemopen2.c index e9d8b63..3c9dc98 100644 --- a/stdio-common/tst-fmemopen2.c +++ b/stdio-common/tst-fmemopen2.c @@ -1,71 +1,253 @@ +/* fmemopen tests. + Copyright (C) 2014-2015 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + + #include #include #include #include - +#include static int -do_test (void) +do_test_with_buffer (void) { int result = 0; char buf[100]; - FILE *fp = fmemopen (buf, sizeof (buf), "w"); + const size_t nbuf = sizeof (buf); + + FILE *fp = fmemopen (buf, nbuf, "w"); if (fp == NULL) { - puts ("fmemopen failed"); - return 0; + printf ("%s: fmemopen failed\n", __FUNCTION__); + return 1; } + static const char str[] = "hello world"; -#define nstr (sizeof (str) - 1) + const size_t nstr = sizeof (str) - 1; fputs (str, fp); off_t o = ftello (fp); if (o != nstr) { - printf ("first ftello returned %jd, expected %zu\n", - (intmax_t) o, nstr); + printf ("%s: first ftello returned %jd, expected %zu\n", + __FUNCTION__, (intmax_t)o, nstr); result = 1; } + rewind (fp); o = ftello (fp); if (o != 0) { - printf ("second ftello returned %jd, expected 0\n", (intmax_t) o); + printf ("%s: second ftello returned %jd, expected 0\n", + __FUNCTION__, (intmax_t)o); result = 1; } if (fseeko (fp, 0, SEEK_END) != 0) { - puts ("fseeko failed"); - return 1; + printf ("%s: fseeko failed\n", __FUNCTION__); + result = 1; } o = ftello (fp); if (o != nstr) { - printf ("third ftello returned %jd, expected %zu\n", - (intmax_t) o, nstr); + printf ("%s: third ftello returned %jd, expected %zu\n", + __FUNCTION__, (intmax_t)o, nbuf); result = 1; } + rewind (fp); static const char str2[] = "just hello"; -#define nstr2 (sizeof (str2) - 1) + const size_t nstr2 = sizeof (str2) - 1; assert (nstr2 < nstr); fputs (str2, fp); o = ftello (fp); if (o != nstr2) { - printf ("fourth ftello returned %jd, expected %zu\n", - (intmax_t) o, nstr2); + printf ("%s: fourth ftello returned %jd, expected %zu\n", + __FUNCTION__, (intmax_t)o, nstr2); result = 1; } fclose (fp); + static const char str3[] = "just hellod"; if (strcmp (buf, str3) != 0) { - printf ("final string is \"%s\", expected \"%s\"\n", - buf, str3); + printf ("%s: final string is \"%s\", expected \"%s\"\n", + __FUNCTION__, buf, str3); + result = 1; + } + return result; +} + +static int +do_test_without_buffer (void) +{ + int result = 0; + const size_t nbuf = 100; + + FILE *fp = fmemopen (NULL, nbuf, "w"); + if (fp == NULL) + { + printf ("%s: fmemopen failed\n", __FUNCTION__); + return 1; + } + + static const char str[] = "hello world"; + const size_t nstr = sizeof (str) - 1; + + fputs (str, fp); + off_t o = ftello (fp); + if (o != nstr) + { + printf ("%s: first ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nstr); + result = 1; + } + if (fseeko (fp, 0, SEEK_END) != 0) + { + printf ("%s: fseeko failed\n", __FUNCTION__); + result = 1; + } + o = ftello (fp); + if (o != nstr) + { + printf ("%s: second ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nbuf); result = 1; } + rewind (fp); + static const char str2[] = "just hello"; + const size_t nstr2 = sizeof (str2) - 1; + assert (nstr2 < nstr); + fputs (str2, fp); + o = ftello (fp); + if (o != nstr2) + { + printf ("%s: third ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nstr2); + result = 1; + } + fclose (fp); + return result; } +static int +do_test_length_zero (void) +{ + int result = 0; + FILE *fp; +#define BUFCONTENTS "testing buffer" + char buf[100] = BUFCONTENTS; + const size_t nbuf = 0; + int r; + + fp = fmemopen (buf, nbuf, "r"); + if (fp == NULL) + { + printf ("%s: fmemopen failed\n", __FUNCTION__); + return 1; + } + + /* Reading any data on a zero-length buffer should return EOF. */ + if ((r = fgetc (fp)) != EOF) + { + printf ("%s: fgetc on a zero-length returned: %d\n", + __FUNCTION__, r); + result = 1; + } + off_t o = ftello (fp); + if (o != 0) + { + printf ("%s: first ftello returned %ld, expected 0\n", + __FUNCTION__, o); + result = 1; + } + fclose (fp); + + /* Writing any data shall start at current position and shall not pass + current buffer size beyond the size in fmemopen call. */ + fp = fmemopen (buf, nbuf, "w"); + if (fp == NULL) + { + printf ("%s: second fmemopen failed\n", __FUNCTION__); + return 1; + } + + static const char str[] = "hello world"; + /* Because of buffering, fputs call itself don't fail, however the final + buffer should be not changed because of length 0 passed in fmemopen + call. */ + fputs (str, fp); + r = 0; + errno = 0; + if (fflush (fp) != EOF) + { + printf ("%s: fflush did not return EOF\n", __FUNCTION__); + fclose (fp); + return 1; + } + if (errno != ENOSPC) + { + printf ("%s: errno is %i (expected %i - ENOSPC)\n", __FUNCTION__, + errno, ENOSPC); + fclose (fp); + return 1; + } + + fclose (fp); + + if (strcmp (buf, BUFCONTENTS) != 0) + { + printf ("%s: strcmp (%s, %s) failed\n", __FUNCTION__, buf, + BUFCONTENTS); + return 1; + } + + /* Different than 'w' mode, 'w+' truncates the buffer. */ + fp = fmemopen (buf, nbuf, "w+"); + if (fp == NULL) + { + printf ("%s: second fmemopen failed\n", __FUNCTION__); + return 1; + } + + fclose (fp); + + if (strcmp (buf, "") != 0) + { + printf ("%s: strcmp (%s, \"\") failed\n", __FUNCTION__, buf); + return 1; + } + + return result; +} + +static int +do_test (void) +{ + int ret = 0; + + ret += do_test_with_buffer (); + ret += do_test_without_buffer (); + ret += do_test_length_zero (); + + return ret; +} + #define TEST_FUNCTION do_test () #include "../test-skeleton.c"