/* GLib testing framework examples and tests
 * Copyright (C) 2008 Red Hat, Inc.
 * Authors: Tomas Bzatek <tbzatek@redhat.com>
 *
 * This work is provided "as is"; redistribution and modification
 * in whole or in part, in any medium, physical or electronic is
 * permitted without restriction.
 *
 * This work 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.
 *
 * In no event shall the authors or contributors be liable for any
 * direct, indirect, incidental, special, exemplary, or consequential
 * damages (including, but not limited to, procurement of substitute
 * goods or services; loss of use, data, or profits; or business
 * interruption) however caused and on any theory of liability, whether
 * in contract, strict liability, or tort (including negligence or
 * otherwise) arising in any way out of the use of this software, even
 * if advised of the possibility of such damage.
 */

#include "config.h"

#include <glib/glib.h>
#include <gio/gio.h>
#include <stdlib.h>
#include <string.h>
#ifdef G_OS_WIN32
#include <stdio.h>
#include <glib/gstdio.h>
#include <windows.h>
#include <shlobj.h>
#include <io.h> /* for _get_osfhandle */
#endif

#define TEST_NAME			"Prilis zlutoucky kun"
#define TEST_DISPLAY_NAME	        "UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88"
#define TEST_SIZE			0xFFFFFFF0

static void
test_assigned_values (GFileInfo *info)
{
  const char *name, *display_name, *mistake;
  guint64 size;
  GFileType type;
  
  /*  Test for attributes presence */
  g_assert_true (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_NAME));
  g_assert_true (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME));
  g_assert_true (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE));
  g_assert_false (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_COPY_NAME));
	
  /*  Retrieve data back and compare */
  
  name = g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_STANDARD_NAME);
  display_name = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME);
  mistake = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_COPY_NAME);
  size = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE);
  type = g_file_info_get_file_type (info);
  
  g_assert_cmpstr (name, ==, TEST_NAME);
  g_assert_cmpstr (display_name, ==, TEST_DISPLAY_NAME);
  g_assert_null (mistake);
  g_assert_cmpint (size, ==, TEST_SIZE);
  g_assert_cmpstr (name, ==, g_file_info_get_name (info));
  g_assert_cmpstr (display_name, ==, g_file_info_get_display_name (info));
  g_assert_cmpint (size, ==, g_file_info_get_size (info)	);
  g_assert_cmpint (type, ==, G_FILE_TYPE_DIRECTORY);
}


static void
test_g_file_info (void)
{
  GFileInfo *info;
  GFileInfo *info_dup;
  GFileInfo *info_copy;
  char **attr_list;
  GFileAttributeMatcher *matcher;
  
  info = g_file_info_new ();
  
  /*  Test for empty instance */
  attr_list = g_file_info_list_attributes (info, NULL);
  g_assert_nonnull (attr_list);
  g_assert_null (*attr_list);
  g_strfreev (attr_list);

  g_file_info_set_attribute_byte_string (info, G_FILE_ATTRIBUTE_STANDARD_NAME, TEST_NAME);
  g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME, TEST_DISPLAY_NAME);
  g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE, TEST_SIZE);
  g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);
	
  /*  The attr list should not be empty now */
  attr_list = g_file_info_list_attributes (info, NULL);
  g_assert_nonnull (attr_list);
  g_assert_nonnull (*attr_list);
  g_strfreev (attr_list);

  test_assigned_values (info);
	
  /*  Test dups */
  info_dup = g_file_info_dup (info);
  g_assert_nonnull (info_dup);
  test_assigned_values (info_dup);
  
  info_copy = g_file_info_new ();
  g_file_info_copy_into (info_dup, info_copy);
  g_assert_nonnull (info_copy);
  test_assigned_values (info_copy);

  /*  Test remove attribute */
  g_assert_false (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER));
  g_file_info_set_attribute_int32 (info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER, 10);
  g_assert_true (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER));

  g_assert_cmpint (g_file_info_get_attribute_type (info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER), ==, G_FILE_ATTRIBUTE_TYPE_INT32);
  g_assert_cmpint (g_file_info_get_attribute_status (info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER), !=, G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING);

  g_file_info_remove_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER);
  g_assert_false (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER));
  g_assert_cmpint (g_file_info_get_attribute_type (info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER), ==, G_FILE_ATTRIBUTE_TYPE_INVALID);

  matcher = g_file_attribute_matcher_new (G_FILE_ATTRIBUTE_STANDARD_NAME ","
                                          G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME);

  g_assert_true (g_file_attribute_matcher_matches (matcher, G_FILE_ATTRIBUTE_STANDARD_NAME));
  g_assert_false (g_file_attribute_matcher_matches_only (matcher, G_FILE_ATTRIBUTE_STANDARD_NAME));
  g_assert_false (g_file_attribute_matcher_matches (matcher, G_FILE_ATTRIBUTE_STANDARD_SIZE));

  g_file_info_set_attribute_mask (info, matcher);
  g_file_attribute_matcher_unref (matcher);

  g_assert_false (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE));
  g_assert_true (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_NAME));

  g_object_unref (info);
  g_object_unref (info_dup);
  g_object_unref (info_copy);
}

static void
test_g_file_info_modification_time (void)
{
  GFile *file = NULL;
  GFileIOStream *io_stream = NULL;
  GFileInfo *info = NULL;
  GDateTime *dt = NULL, *dt_usecs = NULL, *dt_new = NULL, *dt_new_usecs = NULL;
  GTimeSpan ts;
  GError *error = NULL;

  g_test_summary ("Test that getting the modification time of a file works.");

  file = g_file_new_tmp ("g-file-info-test-XXXXXX", &io_stream, &error);
  g_assert_no_error (error);

  info = g_file_query_info (file,
                            G_FILE_ATTRIBUTE_TIME_MODIFIED,
                            G_FILE_QUERY_INFO_NONE,
                            NULL, &error);
  g_assert_no_error (error);

  /* Check the modification time is retrievable. */
  dt = g_file_info_get_modification_date_time (info);
  g_assert_nonnull (dt);

  /* Try again with microsecond precision. */
  g_clear_object (&info);
  info = g_file_query_info (file,
                            G_FILE_ATTRIBUTE_TIME_MODIFIED "," G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,
                            G_FILE_QUERY_INFO_NONE,
                            NULL, &error);
  g_assert_no_error (error);

  dt_usecs = g_file_info_get_modification_date_time (info);
  g_assert_nonnull (dt_usecs);

  ts = g_date_time_difference (dt_usecs, dt);
  g_assert_cmpint (ts, >, 0);
  g_assert_cmpint (ts, <, G_USEC_PER_SEC);

  /* Try round-tripping the modification time. */
  dt_new = g_date_time_add (dt_usecs, G_USEC_PER_SEC + 50);
  g_file_info_set_modification_date_time (info, dt_new);

  dt_new_usecs = g_file_info_get_modification_date_time (info);
  ts = g_date_time_difference (dt_new_usecs, dt_new);
  g_assert_cmpint (ts, ==, 0);

  /* Clean up. */
  g_clear_object (&io_stream);
  g_file_delete (file, NULL, NULL);
  g_clear_object (&file);

  g_clear_object (&info);
  g_date_time_unref (dt);
  g_date_time_unref (dt_usecs);
  g_date_time_unref (dt_new);
  g_date_time_unref (dt_new_usecs);
}

static void
test_g_file_info_access_time (void)
{
  GFile *file = NULL;
  GFileIOStream *io_stream = NULL;
  GFileInfo *info = NULL;
  GDateTime *dt = NULL, *dt_usecs = NULL, *dt_new = NULL, *dt_new_usecs = NULL,
            *dt_before_epoch = NULL, *dt_before_epoch_returned = NULL;
  GTimeSpan ts;
  GError *error = NULL;

  g_test_summary ("Test that getting the access time of a file works.");

  file = g_file_new_tmp ("g-file-info-test-XXXXXX", &io_stream, &error);
  g_assert_no_error (error);

  info = g_file_query_info (file,
                            G_FILE_ATTRIBUTE_TIME_ACCESS,
                            G_FILE_QUERY_INFO_NONE,
                            NULL, &error);
  g_assert_no_error (error);

  /* Check the access time is retrievable. */
  dt = g_file_info_get_access_date_time (info);
  g_assert_nonnull (dt);

  /* Try again with microsecond precision. */
  g_clear_object (&info);
  info = g_file_query_info (file,
                            G_FILE_ATTRIBUTE_TIME_ACCESS "," G_FILE_ATTRIBUTE_TIME_ACCESS_USEC,
                            G_FILE_QUERY_INFO_NONE,
                            NULL, &error);
  g_assert_no_error (error);

  dt_usecs = g_file_info_get_access_date_time (info);
  g_assert_nonnull (dt_usecs);

  ts = g_date_time_difference (dt_usecs, dt);
  g_assert_cmpint (ts, >, 0);
  g_assert_cmpint (ts, <, G_USEC_PER_SEC);

  /* Try round-tripping the access time. */
  dt_new = g_date_time_add (dt_usecs, G_USEC_PER_SEC + 50);
  g_file_info_set_access_date_time (info, dt_new);

  dt_new_usecs = g_file_info_get_access_date_time (info);
  ts = g_date_time_difference (dt_new_usecs, dt_new);
  g_assert_cmpint (ts, ==, 0);

  // try with a negative timestamp
  dt_before_epoch = g_date_time_new_from_unix_utc (-10000);
  g_file_info_set_access_date_time (info, dt_before_epoch);
  dt_before_epoch_returned = g_file_info_get_access_date_time (info);
  ts = g_date_time_difference (dt_before_epoch, dt_before_epoch_returned);
  g_assert_cmpint (ts, ==, 0);

  /* Clean up. */
  g_clear_object (&io_stream);
  g_file_delete (file, NULL, NULL);
  g_clear_object (&file);

  g_clear_object (&info);
  g_date_time_unref (dt);
  g_date_time_unref (dt_usecs);
  g_date_time_unref (dt_new);
  g_date_time_unref (dt_new_usecs);
  g_date_time_unref (dt_before_epoch);
  g_date_time_unref (dt_before_epoch_returned);
}

static void
test_g_file_info_creation_time (void)
{
  GFile *file = NULL;
  GFileIOStream *io_stream = NULL;
  GFileInfo *info = NULL;
  GDateTime *dt = NULL, *dt_usecs = NULL, *dt_new = NULL, *dt_new_usecs = NULL,
            *dt_before_epoch = NULL, *dt_before_epoch_returned = NULL;
  GTimeSpan ts;
  GError *error = NULL;

  g_test_summary ("Test that getting the creation time of a file works.");

  file = g_file_new_tmp ("g-file-info-test-XXXXXX", &io_stream, &error);
  g_assert_no_error (error);

  info = g_file_query_info (file,
                            G_FILE_ATTRIBUTE_TIME_CREATED,
                            G_FILE_QUERY_INFO_NONE,
                            NULL, &error);
  g_assert_no_error (error);

  /* Check the creation time is retrievable. */
  dt = g_file_info_get_creation_date_time (info);
  if (!dt)
    {
      g_test_skip ("Skipping testing creation time as it’s not supported by the kernel");
      g_file_delete (file, NULL, NULL);
      g_clear_object (&file);
      g_clear_object (&info);
      return;
    }

  /* Try again with microsecond precision. */
  g_clear_object (&info);
  info = g_file_query_info (file,
                            G_FILE_ATTRIBUTE_TIME_CREATED "," G_FILE_ATTRIBUTE_TIME_CREATED_USEC,
                            G_FILE_QUERY_INFO_NONE,
                            NULL, &error);
  g_assert_no_error (error);

  dt_usecs = g_file_info_get_creation_date_time (info);
  g_assert_nonnull (dt_usecs);

  ts = g_date_time_difference (dt_usecs, dt);
  g_assert_cmpint (ts, >, 0);
  g_assert_cmpint (ts, <, G_USEC_PER_SEC);

  /* Try round-tripping the creation time. */
  dt_new = g_date_time_add (dt_usecs, G_USEC_PER_SEC + 50);
  g_file_info_set_creation_date_time (info, dt_new);

  dt_new_usecs = g_file_info_get_creation_date_time (info);
  ts = g_date_time_difference (dt_new_usecs, dt_new);
  g_assert_cmpint (ts, ==, 0);

  // try with a negative timestamp
  dt_before_epoch = g_date_time_new_from_unix_utc (-10000);
  g_file_info_set_creation_date_time (info, dt_before_epoch);
  dt_before_epoch_returned = g_file_info_get_creation_date_time (info);
  ts = g_date_time_difference (dt_before_epoch, dt_before_epoch_returned);
  g_assert_cmpint (ts, ==, 0);

  /* Clean up. */
  g_clear_object (&io_stream);
  g_file_delete (file, NULL, NULL);
  g_clear_object (&file);

  g_clear_object (&info);
  g_date_time_unref (dt);
  g_date_time_unref (dt_usecs);
  g_date_time_unref (dt_new);
  g_date_time_unref (dt_new_usecs);
  g_date_time_unref (dt_before_epoch);
  g_date_time_unref (dt_before_epoch_returned);
}

#ifdef G_OS_WIN32
static void
test_internal_enhanced_stdio (void)
{
  char *p0, *p1, *ps;
  gboolean try_sparse;
  gchar *tmp_dir_root;
  wchar_t *tmp_dir_root_w;
  gchar *c;
  DWORD fsflags;
  FILE *f;
  SYSTEMTIME st;
  FILETIME ft;
  HANDLE h;
  GStatBuf statbuf_p0, statbuf_p1, statbuf_ps;
  GFile *gf_p0, *gf_p1, *gf_ps;
  GFileInfo *fi_p0, *fi_p1, *fi_ps;
  guint64 size_p0, alsize_p0, size_ps, alsize_ps;
  const gchar *id_p0;
  const gchar *id_p1;
  guint64 time_p0;
  gchar *tmp_dir;
  wchar_t *programdata_dir_w;
  wchar_t *users_dir_w;
  static const GUID folder_id_programdata = 
    { 0x62AB5D82, 0xFDC1, 0x4DC3, { 0xA9, 0xDD, 0x07, 0x0D, 0x1D, 0x49, 0x5D, 0x97 } };
  static const GUID folder_id_users = 
    { 0x0762D272, 0xC50A, 0x4BB0, { 0xA3, 0x82, 0x69, 0x7D, 0xCD, 0x72, 0x9B, 0x80 } };
  GDateTime *dt = NULL, *dt2 = NULL;
  GTimeSpan ts;
  /* Just before SYSTEMTIME limit (Jan 1 30827) */
  const gint64 one_sec_before_systemtime_limit = 910670515199;
  gboolean retval;
  GError *local_error = NULL;


  programdata_dir_w = NULL;
  SHGetKnownFolderPath (&folder_id_programdata, 0, NULL, &programdata_dir_w);

  users_dir_w = NULL;
  SHGetKnownFolderPath (&folder_id_users, 0, NULL, &users_dir_w);

  if (programdata_dir_w != NULL && users_dir_w != NULL)
    {
      gchar *programdata;
      gchar *users_dir;
      gchar *allusers;
      gchar *commondata;
      GFile *gf_programdata, *gf_allusers, *gf_commondata;
      GFileInfo *fi_programdata, *fi_allusers, *fi_allusers_target, *fi_commondata, *fi_commondata_target;
      GFileType ft_allusers;
      GFileType ft_allusers_target;
      GFileType ft_programdata;
      GFileType ft_commondata;
      gboolean allusers_is_symlink;
      gboolean commondata_is_symlink;
      gboolean commondata_is_mount_point;
      guint32 allusers_reparse_tag;
      guint32 commondata_reparse_tag;
      const gchar *id_allusers;
      const gchar *id_allusers_target;
      const gchar *id_commondata_target;
      const gchar *id_programdata;
      const gchar *allusers_target;
      const gchar *commondata_target;

      /* C:/ProgramData */
      programdata = g_utf16_to_utf8 (programdata_dir_w, -1, NULL, NULL, NULL);
      g_assert_nonnull (programdata);
      /* C:/Users */
      users_dir = g_utf16_to_utf8 (users_dir_w, -1, NULL, NULL, NULL);
      g_assert_nonnull (users_dir);
      /* "C:/Users/All Users" is a known directory symlink
       * for "C:/ProgramData".
       */
      allusers = g_build_filename (users_dir, "All Users", NULL);

      /* "C:/Users/All Users/Application Data" is a known
       * junction for "C:/ProgramData"
       */
      commondata = g_build_filename (allusers, "Application Data", NULL);

      /* We don't test g_stat() and g_lstat() on these directories,
       * because it is pointless - there's no way to tell that these
       * functions behave correctly in this case
       * (st_ino is useless, so we can't tell apart g_stat() and g_lstat()
       *  results; st_mode is also useless as it does not support S_ISLNK;
       *  and these directories have no interesting properties other
       *  than [not] being symlinks).
       */
      gf_programdata = g_file_new_for_path (programdata);
      gf_allusers = g_file_new_for_path (allusers);
      gf_commondata = g_file_new_for_path (commondata);

      fi_programdata = g_file_query_info (gf_programdata,
                                          G_FILE_ATTRIBUTE_ID_FILE ","
                                          G_FILE_ATTRIBUTE_STANDARD_TYPE,
                                          G_FILE_QUERY_INFO_NONE,
                                          NULL, NULL);

      fi_allusers_target = g_file_query_info (gf_allusers,
                                              G_FILE_ATTRIBUTE_ID_FILE ","
                                              G_FILE_ATTRIBUTE_STANDARD_TYPE,
                                              G_FILE_QUERY_INFO_NONE,
                                              NULL, NULL);

      fi_allusers = g_file_query_info (gf_allusers,
                                       G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET ","
                                       G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK ","
                                       G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG ","
                                       G_FILE_ATTRIBUTE_ID_FILE ","
                                       G_FILE_ATTRIBUTE_STANDARD_TYPE,
                                       G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
                                       NULL, NULL);

      fi_commondata = g_file_query_info (gf_commondata,
                                         G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET ","
                                         G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK ","
                                         G_FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT ","
                                         G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG ","
                                         G_FILE_ATTRIBUTE_ID_FILE ","
                                         G_FILE_ATTRIBUTE_STANDARD_TYPE,
                                         G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
                                         NULL, NULL);

      fi_commondata_target = g_file_query_info (gf_commondata,
                                                G_FILE_ATTRIBUTE_ID_FILE ","
                                                G_FILE_ATTRIBUTE_STANDARD_TYPE,
                                                G_FILE_QUERY_INFO_NONE,
                                                NULL, NULL);

      g_assert_true (g_file_info_has_attribute (fi_programdata, G_FILE_ATTRIBUTE_ID_FILE));
      g_assert_true (g_file_info_has_attribute (fi_programdata, G_FILE_ATTRIBUTE_STANDARD_TYPE));

      g_assert_true (g_file_info_has_attribute (fi_allusers_target, G_FILE_ATTRIBUTE_ID_FILE));
      g_assert_true (g_file_info_has_attribute (fi_allusers_target, G_FILE_ATTRIBUTE_STANDARD_TYPE));
      g_assert_true (g_file_info_has_attribute (fi_commondata_target, G_FILE_ATTRIBUTE_ID_FILE));
      g_assert_true (g_file_info_has_attribute (fi_commondata_target, G_FILE_ATTRIBUTE_STANDARD_TYPE));

      g_assert_true (g_file_info_has_attribute (fi_allusers, G_FILE_ATTRIBUTE_ID_FILE));
      g_assert_true (g_file_info_has_attribute (fi_allusers, G_FILE_ATTRIBUTE_STANDARD_TYPE));
      g_assert_true (g_file_info_has_attribute (fi_allusers, G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK));
      g_assert_true (g_file_info_has_attribute (fi_allusers, G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG));
      g_assert_true (g_file_info_has_attribute (fi_allusers, G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET));

      g_assert_true (g_file_info_has_attribute (fi_commondata, G_FILE_ATTRIBUTE_ID_FILE));
      g_assert_true (g_file_info_has_attribute (fi_commondata, G_FILE_ATTRIBUTE_STANDARD_TYPE));
      g_assert_true (g_file_info_has_attribute (fi_commondata, G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK));
      g_assert_true (g_file_info_has_attribute (fi_commondata, G_FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT));
      g_assert_true (g_file_info_has_attribute (fi_commondata, G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG));
      g_assert_true (g_file_info_has_attribute (fi_commondata, G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET));

      ft_allusers = g_file_info_get_file_type (fi_allusers);
      ft_allusers_target = g_file_info_get_file_type (fi_allusers_target);
      ft_programdata = g_file_info_get_file_type (fi_programdata);
      ft_commondata = g_file_info_get_file_type (fi_commondata);

      g_assert_cmpint (ft_allusers, ==, G_FILE_TYPE_DIRECTORY);
      g_assert_cmpint (ft_allusers_target, ==, G_FILE_TYPE_DIRECTORY);
      g_assert_cmpint (ft_programdata, ==, G_FILE_TYPE_DIRECTORY);
      g_assert_cmpint (ft_commondata, ==, G_FILE_TYPE_DIRECTORY);

      allusers_is_symlink = g_file_info_get_attribute_boolean (fi_allusers, G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK);
      allusers_reparse_tag = g_file_info_get_attribute_uint32 (fi_allusers, G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG);
      commondata_is_symlink = g_file_info_get_attribute_boolean (fi_commondata, G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK);
      commondata_is_mount_point = g_file_info_get_attribute_boolean (fi_commondata, G_FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT);
      commondata_reparse_tag = g_file_info_get_attribute_uint32 (fi_commondata, G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG);

      g_assert_true (allusers_is_symlink);
      g_assert_cmpuint (allusers_reparse_tag, ==, IO_REPARSE_TAG_SYMLINK);
      g_assert_true (commondata_is_symlink);
      g_assert_true (commondata_is_mount_point);
      g_assert_cmpuint (commondata_reparse_tag, ==, IO_REPARSE_TAG_MOUNT_POINT);

      id_allusers = g_file_info_get_attribute_string (fi_allusers, G_FILE_ATTRIBUTE_ID_FILE);
      id_allusers_target = g_file_info_get_attribute_string (fi_allusers_target, G_FILE_ATTRIBUTE_ID_FILE);
      id_commondata_target = g_file_info_get_attribute_string (fi_commondata_target, G_FILE_ATTRIBUTE_ID_FILE);
      id_programdata = g_file_info_get_attribute_string (fi_programdata, G_FILE_ATTRIBUTE_ID_FILE);

      g_assert_cmpstr (id_allusers_target, ==, id_programdata);
      g_assert_cmpstr (id_commondata_target, ==, id_programdata);
      g_assert_cmpstr (id_allusers, !=, id_programdata);

      allusers_target = g_file_info_get_symlink_target (fi_allusers);

      g_assert_true (g_str_has_suffix (allusers_target, "ProgramData"));

      commondata_target = g_file_info_get_symlink_target (fi_commondata);

      g_assert_true (g_str_has_suffix (commondata_target, "ProgramData"));

      g_object_unref (fi_allusers);
      g_object_unref (fi_allusers_target);
      g_object_unref (fi_commondata);
      g_object_unref (fi_commondata_target);
      g_object_unref (fi_programdata);
      g_object_unref (gf_allusers);
      g_object_unref (gf_commondata);
      g_object_unref (gf_programdata);

      g_free (allusers);
      g_free (commondata);
      g_free (users_dir);
      g_free (programdata);
    }

  if (programdata_dir_w)
    CoTaskMemFree (programdata_dir_w);

  if (users_dir_w)
    CoTaskMemFree (users_dir_w);

  tmp_dir = g_dir_make_tmp ("glib_stdio_testXXXXXX", NULL);
  g_assert_nonnull (tmp_dir);

  /* Technically, this isn't necessary - we already assume NTFS, because of
   * symlink support, and NTFS also supports sparse files. Still, given
   * the amount of unusual I/O APIs called in this test, checking for
   * sparse file support of the filesystem where temp directory is
   * doesn't seem to be out of place.
   */
  try_sparse = FALSE;
  tmp_dir_root = g_strdup (tmp_dir);
  /* We need "C:\\" or "C:/", with a trailing [back]slash */
  for (c = tmp_dir_root; c && c[0] && c[1]; c++)
    if (c[0] == ':')
      {
        c[2] = '\0';
        break;
      }
  tmp_dir_root_w = g_utf8_to_utf16 (tmp_dir_root, -1, NULL, NULL, NULL);
  g_assert_nonnull (tmp_dir_root_w);
  g_free (tmp_dir_root);
  g_assert_true (GetVolumeInformationW (tmp_dir_root_w, NULL, 0, NULL, NULL, &fsflags, NULL, 0));
  g_free (tmp_dir_root_w);
  try_sparse = (fsflags & FILE_SUPPORTS_SPARSE_FILES) == FILE_SUPPORTS_SPARSE_FILES;

  p0 = g_build_filename (tmp_dir, "zool", NULL);
  p1 = g_build_filename (tmp_dir, "looz", NULL);
  ps = g_build_filename (tmp_dir, "sparse", NULL);

  if (try_sparse)
    {
      FILE_SET_SPARSE_BUFFER ssb;
      FILE_ZERO_DATA_INFORMATION zdi;

      g_remove (ps);

      f = g_fopen (ps, "wb");
      g_assert_nonnull (f);

      h = (HANDLE) _get_osfhandle (fileno (f));
      g_assert_cmpuint ((guintptr) h, !=, (guintptr) INVALID_HANDLE_VALUE);

      ssb.SetSparse = TRUE;
      g_assert_true (DeviceIoControl (h,
                     FSCTL_SET_SPARSE,
                     &ssb, sizeof (ssb),
                     NULL, 0, NULL, NULL));

      /* Make it a sparse file that starts with 4GBs of zeros */
      zdi.FileOffset.QuadPart = 0;
      zdi.BeyondFinalZero.QuadPart = 0xFFFFFFFFULL + 1;
      g_assert_true (DeviceIoControl (h,
                     FSCTL_SET_ZERO_DATA,
                     &zdi, sizeof (zdi),
                     NULL, 0, NULL, NULL));

      /* Let's not keep this seemingly 4GB monster around
       * longer than we absolutely need to. Do all operations
       * without assertions, then remove the file immediately.
       */
      _fseeki64 (f, 0xFFFFFFFFULL, SEEK_SET);
      fprintf (f, "Hello 4GB World!");
      fflush (f);
      fclose (f);

      memset (&statbuf_ps, 0, sizeof (statbuf_ps));

      g_stat (ps, &statbuf_ps);

      gf_ps = g_file_new_for_path (ps);

      fi_ps = g_file_query_info (gf_ps,
                                 G_FILE_ATTRIBUTE_STANDARD_SIZE ","
                                 G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE,
                                 G_FILE_QUERY_INFO_NONE,
                                 NULL, NULL);

      g_remove (ps);

      g_assert_true (g_file_info_has_attribute (fi_ps, G_FILE_ATTRIBUTE_STANDARD_SIZE));
      g_assert_true (g_file_info_has_attribute (fi_ps, G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE));

      size_ps = g_file_info_get_attribute_uint64 (fi_ps, G_FILE_ATTRIBUTE_STANDARD_SIZE);
      alsize_ps = g_file_info_get_attribute_uint64 (fi_ps, G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE);

      /* allocated size should small (usually - size of the FS cluster,
       * let's assume it's less than 1 gigabyte),
       * size should be more than 4 gigabytes,
       * st_size should not exceed its 0xFFFFFFFF 32-bit limit,
       * and should be nonzero (this also detects a failed g_stat() earlier).
       */
      g_assert_cmpuint (alsize_ps, <, 0x40000000);
      g_assert_cmpuint (size_ps, >, G_GUINT64_CONSTANT (0xFFFFFFFF));
      g_assert_cmpuint (statbuf_ps.st_size, >, 0);
      g_assert_cmpuint (statbuf_ps.st_size, <=, 0xFFFFFFFF);

      g_object_unref (fi_ps);
      g_object_unref (gf_ps);
    }

  /* Wa-a-ay past 02/07/2106 @ 6:28am (UTC),
   * which is the date corresponding to 0xFFFFFFFF + 1.
   * This is easier to check than Y2038 (0x80000000 + 1),
   * since there's no need to worry about signedness this way.
   */
  st.wYear = 2106;
  st.wMonth = 2;
  st.wDay = 9;
  st.wHour = 0;
  st.wMinute = 0;
  st.wSecond = 0;
  st.wMilliseconds = 0;

  g_assert_true (SystemTimeToFileTime (&st, &ft));

  f = g_fopen (p0, "w");
  g_assert_nonnull (f);

  h = (HANDLE) _get_osfhandle (fileno (f));
  g_assert_cmpuint ((guintptr) h, !=, (guintptr) INVALID_HANDLE_VALUE);

  fprintf (f, "1");
  fflush (f);

  g_assert_true (SetFileTime (h, &ft, &ft, &ft));

  fclose (f);

  f = g_fopen (p1, "w");
  g_assert_nonnull (f);

  fclose (f);

  memset (&statbuf_p0, 0, sizeof (statbuf_p0));
  memset (&statbuf_p1, 0, sizeof (statbuf_p1));

  g_assert_cmpint (g_stat (p0, &statbuf_p0), ==, 0);
  g_assert_cmpint (g_stat (p1, &statbuf_p1), ==, 0);

  gf_p0 = g_file_new_for_path (p0);
  gf_p1 = g_file_new_for_path (p1);

  fi_p0 = g_file_query_info (gf_p0,
                             G_FILE_ATTRIBUTE_STANDARD_SIZE ","
                             G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE ","
                             G_FILE_ATTRIBUTE_ID_FILE ","
                             G_FILE_ATTRIBUTE_TIME_MODIFIED ","
                             G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,
                             G_FILE_QUERY_INFO_NONE,
                             NULL, NULL);

  fi_p1 = g_file_query_info (gf_p1,
                             G_FILE_ATTRIBUTE_STANDARD_SIZE ","
                             G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE ","
                             G_FILE_ATTRIBUTE_ID_FILE ","
                             G_FILE_ATTRIBUTE_TIME_MODIFIED ","
                             G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,
                             G_FILE_QUERY_INFO_NONE,
                             NULL, NULL);

  g_assert_true (g_file_info_has_attribute (fi_p0, G_FILE_ATTRIBUTE_STANDARD_SIZE));
  g_assert_true (g_file_info_has_attribute (fi_p0, G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE));
  g_assert_true (g_file_info_has_attribute (fi_p0, G_FILE_ATTRIBUTE_ID_FILE));
  g_assert_true (g_file_info_has_attribute (fi_p0, G_FILE_ATTRIBUTE_TIME_MODIFIED));
  g_assert_true (g_file_info_has_attribute (fi_p0, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC));

  g_assert_true (g_file_info_has_attribute (fi_p1, G_FILE_ATTRIBUTE_STANDARD_SIZE));
  g_assert_true (g_file_info_has_attribute (fi_p1, G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE));
  g_assert_true (g_file_info_has_attribute (fi_p1, G_FILE_ATTRIBUTE_ID_FILE));
  g_assert_true (g_file_info_has_attribute (fi_p1, G_FILE_ATTRIBUTE_TIME_MODIFIED));
  g_assert_true (g_file_info_has_attribute (fi_p1, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC));

  size_p0 = g_file_info_get_attribute_uint64 (fi_p0, G_FILE_ATTRIBUTE_STANDARD_SIZE);
  alsize_p0 = g_file_info_get_attribute_uint64 (fi_p0, G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE);

  /* size should be 1, allocated size should be something else
   * (could be 0 or the size of the FS cluster, but never 1).
   */
  g_assert_cmpuint (size_p0, ==, statbuf_p0.st_size);
  g_assert_cmpuint (size_p0, ==, 1);
  g_assert_cmpuint (alsize_p0, !=, size_p0);

  id_p0 = g_file_info_get_attribute_string (fi_p0, G_FILE_ATTRIBUTE_ID_FILE);
  id_p1 = g_file_info_get_attribute_string (fi_p1, G_FILE_ATTRIBUTE_ID_FILE);

  /* st_ino from W32 stat() is useless for file identification.
   * It will be either 0, or it will be the same for both files.
   */
  g_assert_cmpint (statbuf_p0.st_ino, ==, statbuf_p1.st_ino);
  g_assert_cmpstr (id_p0, !=, id_p1);

  time_p0 = g_file_info_get_attribute_uint64 (fi_p0, G_FILE_ATTRIBUTE_TIME_MODIFIED);

  /* Check that GFileInfo doesn't suffer from Y2106 problem.
   * Don't check stat(), as its contents may vary depending on
   * the host platform architecture
   * (time fields are 32-bit on 32-bit Windows,
   *  and 64-bit on 64-bit Windows, usually),
   * so it *can* pass this test in some cases.
   */
  g_assert_cmpuint (time_p0, >, G_GUINT64_CONSTANT (0xFFFFFFFF));

  dt = g_file_info_get_modification_date_time (fi_p0);
  g_assert_nonnull (dt);
  dt2 = g_date_time_add (dt, G_USEC_PER_SEC / 100 * 200);
  g_object_unref (fi_p0);
  fi_p0 = g_file_info_new ();
  g_file_info_set_modification_date_time (fi_p0, dt2);

  g_assert_true (g_file_set_attributes_from_info (gf_p0,
                                                  fi_p0,
                                                  G_FILE_QUERY_INFO_NONE,
                                                  NULL,
                                                  NULL));
  g_date_time_unref (dt2);
  g_object_unref (fi_p0);
  fi_p0 = g_file_query_info (gf_p0,
                             G_FILE_ATTRIBUTE_TIME_MODIFIED ","
                             G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,
                             G_FILE_QUERY_INFO_NONE,
                             NULL, NULL);
  dt2 = g_file_info_get_modification_date_time (fi_p0);
  ts = g_date_time_difference (dt2, dt);
  g_assert_cmpint (ts, >, 0);
  g_assert_cmpint (ts, <, G_USEC_PER_SEC / 100 * 300);

  g_date_time_unref (dt);
  g_date_time_unref (dt2);

  g_file_info_set_attribute_uint64 (fi_p0,
                                    G_FILE_ATTRIBUTE_TIME_MODIFIED,
                                    one_sec_before_systemtime_limit);
  g_file_info_set_attribute_uint32 (fi_p0, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC, 0);
  g_assert_true (g_file_set_attributes_from_info (gf_p0,
                                                  fi_p0,
                                                  G_FILE_QUERY_INFO_NONE,
                                                  NULL,
                                                  NULL));

  g_file_info_set_attribute_uint64 (fi_p0,
                                   G_FILE_ATTRIBUTE_TIME_MODIFIED,
                                   one_sec_before_systemtime_limit + G_USEC_PER_SEC * 2);
  g_file_info_set_attribute_uint32 (fi_p0, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC, 0);
  retval = g_file_set_attributes_from_info (gf_p0,
                                            fi_p0,
                                            G_FILE_QUERY_INFO_NONE,
                                            NULL,
                                            &local_error);
  g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA);
  g_assert_false (retval);
  g_clear_error (&local_error);

  g_object_unref (fi_p0);
  g_object_unref (fi_p1);
  g_object_unref (gf_p0);
  g_object_unref (gf_p1);
  g_remove (p0);
  g_remove (p1);
  g_free (p0);
  g_free (p1);
  g_rmdir (tmp_dir);
}
#endif

static void
test_xattrs (void)
{
  GFile *file = NULL;
  GFileIOStream *stream = NULL;
  GFileInfo *file_info0 = NULL, *file_info1 = NULL;
  GError *local_error = NULL;

  g_test_summary ("Test setting and getting escaped xattrs");

  /* Create a temporary file; no need to write anything to it. */
  file = g_file_new_tmp ("g-file-info-test-xattrs-XXXXXX", &stream, &local_error);
  g_assert_no_error (local_error);
  g_assert_nonnull (file);

  g_io_stream_close (G_IO_STREAM (stream), NULL, NULL);
  g_object_unref (stream);

  /* Check the existing xattrs. */
  file_info0 = g_file_query_info (file, "xattr::*", G_FILE_QUERY_INFO_NONE, NULL, &local_error);
  g_assert_no_error (local_error);
  g_assert_nonnull (file_info0);

  /* Set some new xattrs, with escaping and some embedded nuls. */
  g_file_info_set_attribute_string (file_info0, "xattr::escaped", "hello\\x82\\x80\\xbd");
  g_file_info_set_attribute_string (file_info0, "xattr::string", "hi there");
  g_file_info_set_attribute_string (file_info0, "xattr::embedded-nul", "hi\\x00there");

  g_file_set_attributes_from_info (file, file_info0, G_FILE_QUERY_INFO_NONE, NULL, &local_error);

  g_object_unref (file_info0);

  if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
    {
      g_test_skip ("xattrs not supported on this file system");
      g_clear_error (&local_error);
    }
  else
    {
      g_assert_no_error (local_error);

      /* Check they were set properly. */
      file_info1 = g_file_query_info (file, "xattr::*", G_FILE_QUERY_INFO_NONE, NULL, &local_error);
      g_assert_no_error (local_error);
      g_assert_nonnull (file_info1);

      g_assert_true (g_file_info_has_namespace (file_info1, "xattr"));

      g_assert_cmpstr (g_file_info_get_attribute_string (file_info1, "xattr::escaped"), ==, "hello\\x82\\x80\\xbd");
      g_assert_cmpstr (g_file_info_get_attribute_string (file_info1, "xattr::string"), ==, "hi there");
      g_assert_cmpstr (g_file_info_get_attribute_string (file_info1, "xattr::embedded-nul"), ==, "hi\\x00there");

      g_object_unref (file_info1);
    }

  /* Tidy up. */
  g_file_delete (file, NULL, NULL);

  g_object_unref (file);
}

int
main (int   argc,
      char *argv[])
{
  g_test_init (&argc, &argv, NULL);

  g_test_add_func ("/g-file-info/test_g_file_info", test_g_file_info);
  g_test_add_func ("/g-file-info/test_g_file_info/modification-time", test_g_file_info_modification_time);
  g_test_add_func ("/g-file-info/test_g_file_info/access-time", test_g_file_info_access_time);
  g_test_add_func ("/g-file-info/test_g_file_info/creation-time", test_g_file_info_creation_time);
#ifdef G_OS_WIN32
  g_test_add_func ("/g-file-info/internal-enhanced-stdio", test_internal_enhanced_stdio);
#endif
  g_test_add_func ("/g-file-info/xattrs", test_xattrs);
  
  return g_test_run();
}