code: def test_load_simple_binary(self):
      for big_endian in [True, False]:
          verts = (
              "0 0 0 "
              "0 0 1 "
              "0 1 1 "
              "0 1 0 "
              "1 0 0 "
              "1 0 1 "
              "1 1 1 "
              "1 1 0"
          ).split()
          faces = (
              "4 0 1 2 3 "
              "4 7 6 5 4 "
              "4 0 4 5 1 "
              "4 1 5 6 2 "
              "4 2 6 7 3 "
              "4 3 7 4 0 "  # end of first 6
              "4 0 1 2 3 "
              "4 7 6 5 4 "
              "3 4 5 1"
          ).split()
          short_one = b"\00\01" if big_endian else b"\01\00"
          mixed_data = b"\00\00" b"\03\03" + (
              short_one + b"\00\01\01\01" b"\00\02"
          )
          minus_one_data = b"\xff" * 14
          endian_char = ">" if big_endian else "<"
          format = (
              "format binary_big_endian 1.0"
              if big_endian
              else "format binary_little_endian 1.0"
          )
          vertex_pattern = endian_char + "24f"
          vertex_data = struct.pack(vertex_pattern, *map(float, verts))
          vertex1_pattern = endian_char + "fdffdffdffdffdffdffdffdf"
          vertex1_data = struct.pack(
              vertex1_pattern, *map(float, verts)
          )
          face_char_pattern = endian_char + "44b"
          face_char_data = struct.pack(
              face_char_pattern, *map(int, faces)
          )
          header = "\n".join(
              [
                  "ply",
                  format,
                  "element vertex 8",
                  "property float x",
                  "property float32 y",
                  "property float z",
                  "element vertex1 8",
                  "property float x",
                  "property double y",
                  "property float z",
                  "element face 6",
                  "property list uchar uchar vertex_index",
                  "element irregular_list 3",
                  "property list uchar uchar vertex_index",
                  "element mixed 2",
                  "property list short uint foo",
                  "property short bar",
                  "element minus_ones 1",
                  "property char 1",
                  "property uchar 2",
                  "property short 3",
                  "property ushort 4",
                  "property int 5",
                  "property uint 6",
                  "end_header\n",
              ]
          )
          ply_file = b"".join(
              [
                  header.encode("ascii"),
                  vertex_data,
                  vertex1_data,
                  face_char_data,
                  mixed_data,
                  minus_one_data,
              ]
          )
          metadata, data = _load_ply_raw(BytesIO(ply_file))
          self.assertFalse(metadata.ascii)
          self.assertEqual(len(data), 6)
          self.assertTupleEqual(data["face"].shape, (6, 4))
          self.assertClose([0, 1, 2, 3], data["face"][0])
          self.assertClose([3, 7, 4, 0], data["face"][5])
  
          [vertex0] = data["vertex"]
          self.assertTupleEqual(vertex0.shape, (8, 3))
          self.assertEqual(len(data["vertex1"]), 3)
          self.assertClose(vertex0, np.column_stack(data["vertex1"]))
          self.assertClose(vertex0.flatten(), list(map(float, verts)))
  
          irregular = data["irregular_list"]
          self.assertEqual(len(irregular), 3)
          self.assertEqual(type(irregular), list)
          [x] = irregular[0]
          self.assertClose(x, [0, 1, 2, 3])
          [x] = irregular[1]
          self.assertClose(x, [7, 6, 5, 4])
          [x] = irregular[2]
          self.assertClose(x, [4, 5, 1])
  
          mixed = data["mixed"]
          self.assertEqual(len(mixed), 2)
          self.assertEqual(len(mixed[0]), 2)
          self.assertEqual(len(mixed[1]), 2)
          self.assertEqual(mixed[0][1], 3 * 256 + 3)
          self.assertEqual(len(mixed[0][0]), 0)
          self.assertEqual(mixed[1][1], (2 if big_endian else 2 * 256))
          base = 1 + 256 + 256 * 256
          self.assertEqual(len(mixed[1][0]), 1)
          self.assertEqual(
              mixed[1][0][0], base if big_endian else 256 * base
          )
  
          self.assertListEqual(
              data["minus_ones"], [-1, 255, -1, 65535, -1, 4294967295]
          )
  
imports: import itertools
  import struct
  import unittest
  from io import BytesIO, StringIO
  from tempfile import NamedTemporaryFile, TemporaryFile
  import numpy
  import pytorch3d.io.ply_io
  import torch
  from iopath.common.file_io import PathManager
  from pytorch3d.io import IO
  from pytorch3d.io.ply_io import load_ply, save_ply
  from pytorch3d.renderer.mesh import TexturesVertex
  from pytorch3d.structures import Meshes, Pointclouds
  from pytorch3d.utils import torus
  from .common_testing import get_tests_dir, TestCaseMixin
label_desc: Use image node_id 20 for calling the TestMeshPlyIO obj's underlying member method code with example usage: obj.test_load_simple_binary() without return types