undefect. CWE-407 — 63 sites patched across 27 ecosystems

Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.

test/jdk/performance/client/SwingMark/src/TableRowTest.java

@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *   - Neither the name of Oracle nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER 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.
+ */
+
+import java.util.ResourceBundle;
+import java.util.Vector;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+import javax.swing.JComponent;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.ListSelectionModel;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableModel;
+import javax.swing.SwingUtilities;
+
+/**
+  * This test is mean to isolate the speed of the JTable.
+  * It creates a JTable and performs the following scenarios :
+  * 1) Remove rows
+  * 2) Add rows
+  * 3) Select rows
+  *    -Single Selection mode
+  *    -Single Selection Interval
+  *    -Multiple Selection Intervas
+  */
+
+public class TableRowTest extends AbstractSwingTest {
+
+    JTable table;
+    DefaultTableModel dataModel;
+    static boolean backingStoreEnabled = true;
+
+    final String[] names = {"First Name", "Last Name", "Favorite Color",
+        "Favorite Number", "Vegetarian"};
+
+    Object[][] data = {{}};
+
+    public JComponent getTestComponent() {
+       loadBundle();
+        JPanel panel = new JPanel();
+        dataModel = new DefaultTableModel(data, names);
+
+        table = new CountTable(dataModel);
+        JScrollPane scrollPane = new JScrollPane(table);
+
+        if (SwingMark.useBlitScrolling) {
+           scrollPane.getViewport().putClientProperty("EnableWindowBlit", Boolean.TRUE);
+        }
+
+        panel.add(scrollPane);
+        return panel;
+    }
+
+    private void loadBundle() {
+      ResourceBundle bundle = ResourceBundle.getBundle("resources.TableRowTest");
+      data = (Object[][])bundle.getObject("TableData");
+    }
+
+    public String getTestName() {
+        return "Table Rows";
+    }
+
+    public void runTest() {
+        testTable(table, 1);
+    }
+
+    public void testTable(JTable currentTable, int scrollBy) {
+        // remove row
+        TableRowAdder rowRemover = new TableRowAdder(currentTable, data, false);
+        while (dataModel.getRowCount() > 0 ) {
+            try {
+                SwingUtilities.invokeLater(rowRemover);
+                rest();
+            }
+            catch (Exception e) {e.printStackTrace();}
+        }
+
+        // add row
+        TableRowAdder rowAdder = new TableRowAdder(currentTable, data, true);
+        while (dataModel.getRowCount() < data.length ) {
+            try {
+                SwingUtilities.invokeAndWait(rowAdder);
+            }
+            catch (Exception e) {e.printStackTrace();}
+        }
+
+
+
+        // Selection Test
+        for ( int m = 0 ; m < 3 ; m ++ ) { // m represents selection mode
+            //  System.out.println("  --------- Selection Mode :" + m );
+
+            TableScroller scroll = new TableScroller(currentTable, scrollBy, m);
+
+            currentTable.clearSelection();
+            for (int i = 0 ; i < currentTable.getRowCount()-1; i++ ) {
+                try {
+                    SwingUtilities.invokeAndWait(scroll);
+                }
+                catch (Exception e) {e.printStackTrace();}
+            }
+        }
+
+    }
+
+    public static void main(String[] args) {
+       if (args.length > 0) {
+          if (args[0].equals("-bs=off")) {
+             backingStoreEnabled = false;
+             System.out.println("BackingStore is off");
+          }
+       }
+        runStandAloneTest(new TableRowTest());
+    }
+
+    class CountTable extends JTable {
+        public CountTable(TableModel tm) {
+            super(tm);
+        }
+        public void paint(Graphics g) {
+            super.paint(g);
+            paintCount++;
+        }
+    }
+
+}
+
+
+class TableScroller implements Runnable {
+    JTable table;
+    int scrollAmount = 1;
+    int currentRowSelection = 0;
+
+
+    public TableScroller(JTable tableToScroll, int scrollBy, int selectionMode) {
+        table = tableToScroll;
+        scrollAmount = scrollBy;
+        table.setSelectionMode( selectionMode);
+    }
+
+    public void run() {
+        int ensureToSeeRow = 0;
+
+        switch ( table.getSelectionModel().getSelectionMode() ) {
+            case ListSelectionModel.SINGLE_SELECTION:
+                table.addRowSelectionInterval(currentRowSelection, currentRowSelection);
+                currentRowSelection++;
+                ensureToSeeRow = currentRowSelection;
+                break;
+            case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
+                currentRowSelection = Math.min(currentRowSelection, table.getRowCount()-1);
+                int maxRow = table.getRowCount()-1;
+                table.addRowSelectionInterval(currentRowSelection,
+                           Math.min(currentRowSelection+5, maxRow));
+                currentRowSelection++;
+                ensureToSeeRow = table.getSelectionModel().getAnchorSelectionIndex() + 4;
+                break;
+            case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
+                table.addRowSelectionInterval(Math.min(currentRowSelection, table.getRowCount()-1),
+                                              Math.min(currentRowSelection+3, table.getRowCount()-1));
+                currentRowSelection = currentRowSelection + 5;
+                ensureToSeeRow = table.getSelectionModel().getAnchorSelectionIndex() + 3;
+                break;
+            default:
+                break;
+        }
+
+        Rectangle cellBound = table.getCellRect(ensureToSeeRow, 0, true);
+        table.scrollRectToVisible(cellBound);
+    }
+}
+
+class TableRowAdder implements Runnable {
+    JTable table;
+    int currentRowSelection = 0;
+    Vector dataVector;
+    int index = 0;
+    Object [][] data;
+    boolean add = true; // false for "remove"
+
+
+    public TableRowAdder(JTable table, Object[][] data, boolean add) {
+        this.table = table;
+        this.data = data;
+        this.add = add;
+    }
+
+    public void run() {
+        DefaultTableModel model = (DefaultTableModel)table.getModel();
+        Rectangle cellBound;
+
+        if ( add ) {
+            model.addRow(data[index]);
+            index++;
+            cellBound = table.getCellRect(table.getRowCount()-1, 0, true);
+        }
+        else {
+            model.removeRow(0 );
+            cellBound = table.getCellRect(0,0,true);
+        }
+
+        table.scrollRectToVisible(cellBound);
+    }
+}